diff --git a/internal/checker/pseudotypenodebuilder.go b/internal/checker/pseudotypenodebuilder.go
index 07d18e55f2..0d70d06c47 100644
--- a/internal/checker/pseudotypenodebuilder.go
+++ b/internal/checker/pseudotypenodebuilder.go
@@ -252,21 +252,23 @@ func (b *NodeBuilderImpl) pseudoParametersToNodeList(params []*pseudochecker.Pse
 func (b *NodeBuilderImpl) pseudoParameterToNode(p *pseudochecker.PseudoParameter) *ast.Node {
 	var dotDotDot *ast.Node
 	var questionMark *ast.Node
-	if p.Rest {
+	if p.Declaration.DotDotDotToken != nil {
 		dotDotDot = b.f.NewToken(ast.KindDotDotDotToken)
 	}
-	if p.Optional {
+	if p.Declaration.QuestionToken != nil || p.Declaration.Initializer != nil {
 		questionMark = b.f.NewToken(ast.KindQuestionToken)
 	}
-	return b.f.NewParameterDeclaration(
+	parameter := b.f.NewParameterDeclaration(
 		nil,
 		dotDotDot,
 		// matches strada behavior of always reserializing param names from scratch
-		b.parameterToParameterDeclarationName(p.Name.Parent.Symbol(), p.Name.Parent),
+		b.parameterToParameterDeclarationName(p.Declaration.Symbol, p.Declaration.AsNode()),
 		questionMark,
 		b.pseudoTypeToNode(p.Type),
 		nil,
 	)
+	b.setCommentRange(parameter, p.Declaration.AsNode())
+	return parameter
 }
 
 // see `typeNodeIsEquivalentToType` in strada, but applied more broadly here, so is setup to handle more equivalences - strada only used it via
@@ -379,7 +381,8 @@ func (b *NodeBuilderImpl) pseudoTypeEquivalentToType(t *pseudochecker.PseudoType
 				for i, p := range d.Parameters {
 					targetParam := targetSig.parameters[i]
 					paramType := b.ch.getTypeOfParameter(targetParam)
-					if !b.pseudoTypeEquivalentToType(p.Type, paramType, p.Optional, false) {
+					isOptional := p.Declaration.QuestionToken != nil || p.Declaration.Initializer != nil
+					if !b.pseudoTypeEquivalentToType(p.Type, paramType, isOptional, false) {
 						if reportErrors {
 							b.ctx.tracker.ReportInferenceFallback(e.Name.Parent)
 						}
@@ -461,16 +464,17 @@ func (b *NodeBuilderImpl) pseudoTypeEquivalentToType(t *pseudochecker.PseudoType
 		}
 		for i, p := range pt.Parameters {
 			targetParam := targetSig.parameters[i]
-			if p.Optional != b.ch.isOptionalParameter(targetParam.ValueDeclaration) {
+			isOptional := p.Declaration.QuestionToken != nil || p.Declaration.Initializer != nil
+			if isOptional != b.ch.isOptionalParameter(targetParam.ValueDeclaration) {
 				if reportErrors {
-					b.ctx.tracker.ReportInferenceFallback(p.Name.Parent)
+					b.ctx.tracker.ReportInferenceFallback(p.Declaration.AsNode())
 				}
 				return false
 			}
 			paramType := b.ch.getTypeOfParameter(targetParam)
-			if !b.pseudoTypeEquivalentToType(p.Type, paramType, p.Optional, false) {
+			if !b.pseudoTypeEquivalentToType(p.Type, paramType, isOptional, false) {
 				if reportErrors {
-					b.ctx.tracker.ReportInferenceFallback(p.Name.Parent)
+					b.ctx.tracker.ReportInferenceFallback(p.Declaration.AsNode())
 				}
 				return false
 			}
diff --git a/internal/pseudochecker/lookup.go b/internal/pseudochecker/lookup.go
index 660e0384aa..ea1d835ea6 100644
--- a/internal/pseudochecker/lookup.go
+++ b/internal/pseudochecker/lookup.go
@@ -659,12 +659,8 @@ func (ch *PseudoChecker) cloneParameters(nodes *ast.NodeList) []*PseudoParameter
 	}
 	result := make([]*PseudoParameter, 0, len(nodes.Nodes))
 	for _, e := range nodes.Nodes {
-		result = append(result, NewPseudoParameter(
-			e.AsParameterDeclaration().DotDotDotToken != nil,
-			e.Name(),
-			e.AsParameterDeclaration().QuestionToken != nil || e.AsParameterDeclaration().Initializer != nil,
-			ch.typeFromParameter(e.AsParameterDeclaration()),
-		))
+		parameter := e.AsParameterDeclaration()
+		result = append(result, NewPseudoParameter(parameter, ch.typeFromParameter(parameter)))
 	}
 	return result
 }
diff --git a/internal/pseudochecker/type.go b/internal/pseudochecker/type.go
index de2f75db2a..3f3fe4a1a7 100644
--- a/internal/pseudochecker/type.go
+++ b/internal/pseudochecker/type.go
@@ -159,14 +159,12 @@ func (t *PseudoType) AsPseudoTypeUnion() *PseudoTypeUnion {
 }
 
 type PseudoParameter struct {
-	Rest     bool
-	Name     *ast.Node
-	Optional bool
-	Type     *PseudoType
+	Declaration *ast.ParameterDeclaration
+	Type        *PseudoType
 }
 
-func NewPseudoParameter(isRest bool, name *ast.Node, isOptional bool, t *PseudoType) *PseudoParameter {
-	return &PseudoParameter{Rest: isRest, Name: name, Optional: isOptional, Type: t}
+func NewPseudoParameter(declaration *ast.ParameterDeclaration, t *PseudoType) *PseudoParameter {
+	return &PseudoParameter{Declaration: declaration, Type: t}
 }
 
 // PseudoTypeSingleCallSignature represents an object type with a single call signature, like an arrow or function expression
diff --git a/testdata/baselines/reference/submodule/compiler/commentsFunction(target=es2015).js b/testdata/baselines/reference/submodule/compiler/commentsFunction(target=es2015).js
index 200f2da3cb..98b32a717f 100644
--- a/testdata/baselines/reference/submodule/compiler/commentsFunction(target=es2015).js
+++ b/testdata/baselines/reference/submodule/compiler/commentsFunction(target=es2015).js
@@ -112,9 +112,9 @@ b: number): void;
 /** fooFunc
  * comment
  */
-declare var fooFunc: (b: string) => string;
-declare var lambdaFoo: (a: number, b: number) => number;
-declare var lambddaNoVarComment: (a: number, b: number) => number;
+declare var fooFunc: (/** fooFunctionValue param */ b: string) => string;
+declare var lambdaFoo: (/**param a*/ a: number, /**param b*/ b: number) => number;
+declare var lambddaNoVarComment: (/**param a*/ a: number, /**param b*/ b: number) => number;
 declare function blah(a: string): void;
 declare function blah2(a: string): void;
 declare function blah3(a: string): void;
diff --git a/testdata/baselines/reference/submodule/compiler/commentsFunction(target=es2015).js.diff b/testdata/baselines/reference/submodule/compiler/commentsFunction(target=es2015).js.diff
deleted file mode 100644
index 0c53b9a103..0000000000
--- a/testdata/baselines/reference/submodule/compiler/commentsFunction(target=es2015).js.diff
+++ /dev/null
@@ -1,15 +0,0 @@
---- old.commentsFunction(target=es2015).js
-+++ new.commentsFunction(target=es2015).js
-@@= skipped -111, +111 lines =@@
- /** fooFunc
-  * comment
-  */
--declare var fooFunc: (/** fooFunctionValue param */ b: string) => string;
--declare var lambdaFoo: (/**param a*/ a: number, /**param b*/ b: number) => number;
--declare var lambddaNoVarComment: (/**param a*/ a: number, /**param b*/ b: number) => number;
-+declare var fooFunc: (b: string) => string;
-+declare var lambdaFoo: (a: number, b: number) => number;
-+declare var lambddaNoVarComment: (a: number, b: number) => number;
- declare function blah(a: string): void;
- declare function blah2(a: string): void;
- declare function blah3(a: string): void;
\ No newline at end of file