Make declaration emitter call resolver.isOptionalParameter

Author: JsonFreeman

src/compiler/checker.ts

@@ -91,7 +91,8 @@ namespace ts {
             getExportsOfModule: getExportsOfModuleAsArray,
 
             getJsxElementAttributesType,
-            getJsxIntrinsicTagNames
+            getJsxIntrinsicTagNames,
+            isOptionalParameter
         };
 
         let unknownSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "unknown");
@@ -14402,6 +14403,7 @@ namespace ts {
                 getBlockScopedVariableId,
                 getReferencedValueDeclaration,
                 getTypeReferenceSerializationKind,
+                isOptionalParameter
             };
         }
 

src/compiler/declarationEmitter.ts

@@ -1371,7 +1371,7 @@ namespace ts {
             else {
                 writeTextOfNode(currentSourceFile, node.name);
             }
-            if (node.initializer || hasQuestionToken(node)) {
+            if (resolver.isOptionalParameter(node)) {
                 write("?");
             }
             decreaseIndent();

src/compiler/types.ts

@@ -1431,6 +1431,7 @@ namespace ts {
 
         getJsxElementAttributesType(elementNode: JsxOpeningLikeElement): Type;
         getJsxIntrinsicTagNames(): Symbol[];
+        isOptionalParameter(node: ParameterDeclaration): boolean;
 
         // Should not be called directly.  Should only be accessed through the Program instance.
         /* @internal */ getDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): Diagnostic[];
@@ -1574,7 +1575,8 @@ namespace ts {
         getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
         getBlockScopedVariableId(node: Identifier): number;
         getReferencedValueDeclaration(reference: Identifier): Declaration;
-        getTypeReferenceSerializationKind(node: TypeReferenceNode): TypeReferenceSerializationKind; 
+        getTypeReferenceSerializationKind(node: TypeReferenceNode): TypeReferenceSerializationKind;
+        isOptionalParameter(node: ParameterDeclaration): boolean;
     }
 
     export const enum SymbolFlags {

src/services/signatureHelp.ts

@@ -569,15 +569,7 @@ namespace ts.SignatureHelp {
                     prefixDisplayParts.push(punctuationPart(SyntaxKind.OpenParenToken));
 
                     let parameters = candidateSignature.parameters;
-                    if (parameters.length > 0) {
-                        signatureHelpParameters = [];
-                        for (let i = 0; i < parameters.length; i++) {
-                            signatureHelpParameters.push(createSignatureHelpParameterAtIndex(candidateSignature, i));
-                        }
-                    }
-                    else {
-                        signatureHelpParameters = emptyArray;
-                    }
+                    signatureHelpParameters = parameters.length > 0 ? map(parameters, createSignatureHelpParameterForParameter) : emptyArray;
                     suffixDisplayParts.push(punctuationPart(SyntaxKind.CloseParenToken));
                 }
 
@@ -615,21 +607,15 @@ namespace ts.SignatureHelp {
                 argumentCount
             };
 
-            function createSignatureHelpParameterAtIndex(signature: Signature, parameterIndex: number): SignatureHelpParameter {
-                let parameter = signature.parameters[parameterIndex];
+            function createSignatureHelpParameterForParameter(parameter: Symbol): SignatureHelpParameter {
                 let displayParts = mapToDisplayParts(writer =>
                     typeChecker.getSymbolDisplayBuilder().buildParameterDisplay(parameter, writer, invocation));
 
-                let parameterDeclaration = <ParameterDeclaration>parameter.valueDeclaration;
-                let isOptional =
-                    hasQuestionToken(parameterDeclaration) ||
-                    parameterDeclaration.initializer && parameterIndex >= signature.minArgumentCount;
-
                 return {
                     name: parameter.name,
                     documentation: parameter.getDocumentationComment(),
                     displayParts,
-                    isOptional
+                    isOptional: typeChecker.isOptionalParameter(<ParameterDeclaration>parameter.valueDeclaration)
                 };
             }
 

tests/baselines/reference/requiredInitializedParameter4.js

@@ -0,0 +1,20 @@
+//// [requiredInitializedParameter4.ts]
+class C1 {
+    method(a = 0, b) { }
+}
+
+//// [requiredInitializedParameter4.js]
+var C1 = (function () {
+    function C1() {
+    }
+    C1.prototype.method = function (a, b) {
+        if (a === void 0) { a = 0; }
+    };
+    return C1;
+})();
+
+
+//// [requiredInitializedParameter4.d.ts]
+declare class C1 {
+    method(a: number, b: any): void;
+}

tests/baselines/reference/requiredInitializedParameter4.symbols

@@ -0,0 +1,9 @@
+=== tests/cases/compiler/requiredInitializedParameter4.ts ===
+class C1 {
+>C1 : Symbol(C1, Decl(requiredInitializedParameter4.ts, 0, 0))
+
+    method(a = 0, b) { }
+>method : Symbol(method, Decl(requiredInitializedParameter4.ts, 0, 10))
+>a : Symbol(a, Decl(requiredInitializedParameter4.ts, 1, 11))
+>b : Symbol(b, Decl(requiredInitializedParameter4.ts, 1, 17))
+}

tests/baselines/reference/requiredInitializedParameter4.types

@@ -0,0 +1,10 @@
+=== tests/cases/compiler/requiredInitializedParameter4.ts ===
+class C1 {
+>C1 : C1
+
+    method(a = 0, b) { }
+>method : (a: number, b: any) => void
+>a : number
+>0 : number
+>b : any
+}

tests/cases/compiler/requiredInitializedParameter4.ts

@@ -0,0 +1,4 @@
+//@declaration: true
+class C1 {
+    method(a = 0, b) { }
+}