microsoft · weswigham · Nov 21, 2019 · Nov 14, 2019 · Nov 21, 2019 · ajafff
diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
@@ -3807,7 +3807,7 @@ namespace ts {
        }

        // Type annotations are TypeScript syntax.
-        if (node.type) {
+        if (node.type || node.exclamationToken) {
            transformFlags |= TransformFlags.AssertTypeScript;
        }


diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
@@ -2741,6 +2741,7 @@ namespace ts {

        function emitVariableDeclaration(node: VariableDeclaration) {
            emit(node.name);
+            emit(node.exclamationToken);
            emitTypeAnnotation(node.type);
            emitInitializer(node.initializer, node.type ? node.type.end : node.name.end, node);
        }

diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
@@ -1937,6 +1937,7 @@ namespace ts {
    }

    export function createVariableDeclaration(name: string | BindingName, type?: TypeNode, initializer?: Expression) {
+        /* Internally, one should probably use createTypeScriptVariableDeclaration instead and handle definite assignment assertions */
        const node = <VariableDeclaration>createSynthesizedNode(SyntaxKind.VariableDeclaration);
        node.name = asName(name);
        node.type = type;
@@ -1945,13 +1946,34 @@ namespace ts {
    }

    export function updateVariableDeclaration(node: VariableDeclaration, name: BindingName, type: TypeNode | undefined, initializer: Expression | undefined) {
+        /* Internally, one should probably use updateTypeScriptVariableDeclaration instead and handle definite assignment assertions */
        return node.name !== name
            || node.type !== type
            || node.initializer !== initializer
            ? updateNode(createVariableDeclaration(name, type, initializer), node)
            : node;
    }

+    /* @internal */
+    export function createTypeScriptVariableDeclaration(name: string | BindingName, exclaimationToken?: Token<SyntaxKind.ExclamationToken>, type?: TypeNode, initializer?: Expression) {
+        const node = <VariableDeclaration>createSynthesizedNode(SyntaxKind.VariableDeclaration);
+        node.name = asName(name);
+        node.type = type;
+        node.initializer = initializer !== undefined ? parenthesizeExpressionForList(initializer) : undefined;
+        node.exclamationToken = exclaimationToken;
+        return node;
+    }
+
+    /* @internal */
+    export function updateTypeScriptVariableDeclaration(node: VariableDeclaration, name: BindingName, exclaimationToken: Token<SyntaxKind.ExclamationToken> | undefined, type: TypeNode | undefined, initializer: Expression | undefined) {
+        return node.name !== name
+            || node.type !== type
+            || node.initializer !== initializer
+            || node.exclamationToken !== exclaimationToken
+            ? updateNode(createTypeScriptVariableDeclaration(name, exclaimationToken, type, initializer), node)
+            : node;
+    }
+
    export function createVariableDeclarationList(declarations: readonly VariableDeclaration[], flags = NodeFlags.None) {
        const node = <VariableDeclarationList>createSynthesizedNode(SyntaxKind.VariableDeclarationList);
        node.flags |= flags & NodeFlags.BlockScoped;

diff --git a/src/compiler/transformers/declarations.ts b/src/compiler/transformers/declarations.ts
@@ -937,7 +937,7 @@ namespace ts {
                        }
                        shouldEnterSuppressNewDiagnosticsContextContext = true;
                        suppressNewDiagnosticContexts = true; // Variable declaration types also suppress new diagnostic contexts, provided the contexts wouldn't be made for binding pattern types
-                        return cleanup(updateVariableDeclaration(input, input.name, ensureType(input, input.type), ensureNoInitializer(input)));
+                        return cleanup(updateTypeScriptVariableDeclaration(input, input.name, /*exclaimationToken*/ undefined, ensureType(input, input.type), ensureNoInitializer(input)));
                    }
                    case SyntaxKind.TypeParameter: {
                        if (isPrivateMethodTypeParameter(input) && (input.default || input.constraint)) {

diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts
@@ -2188,9 +2188,10 @@ namespace ts {
        }

        function visitVariableDeclaration(node: VariableDeclaration) {
-            return updateVariableDeclaration(
+            return updateTypeScriptVariableDeclaration(
                node,
                visitNode(node.name, visitor, isBindingName),
+                /*exclaimationToken*/ undefined,
                /*type*/ undefined,
                visitNode(node.initializer, visitor, isExpression));
        }

diff --git a/src/testRunner/unittests/printer.ts b/src/testRunner/unittests/printer.ts
@@ -67,6 +67,17 @@ namespace ts {
                `class A extends B implements C implements D {}`,
                ScriptTarget.ES2017
            )));
+
+            // github #35093
+            printsCorrectly("definiteAssignmentAssertions", {}, printer => printer.printFile(createSourceFile(
+                "source.ts",
+                `class A {
+                    prop!: string;
+                }
+
+                let x!: string;`,
+                ScriptTarget.ES2017
+            )));
        });

        describe("printBundle", () => {

diff --git a/tests/baselines/reference/printerApi/printsFileCorrectly.definiteAssignmentAssertions.js b/tests/baselines/reference/printerApi/printsFileCorrectly.definiteAssignmentAssertions.js
@@ -0,0 +1,4 @@
+class A {
+    prop!: string;
+}
+let x!: string;
-Original file line number
+Diff line change
@@ -3807,7 +3807,7 @@ namespace ts {
             }
             // Type annotations are TypeScript syntax.
-            if (node.type) {
+            if (node.type || node.exclamationToken) {
         Comment thread


        

        
      

        
          


  
    
        
        
  
    
      
          
      

      
            ajafff
  

      

      

      


        Nov 14, 2019



      
    

  

  
    
      
          
    
  


        
            
  
      
              Copy link

  
              
  
      
                Copy Markdown

  
        
      
    

    
        

  
    Contributor


        

    
  


        
      
  
  
  
    

    There was a problem hiding this comment.


  

 
  
    

    Choose a reason for hiding this comment

    
      The reason will be displayed to describe this comment to others. Learn more.
    

    
      
      


  


  
    
      is this change related to the emitter?

If so, you probably also want to make the same change in computePropertyDeclaration (see #35097 which I erroneously opened)
    
  
  



    

        
      
  
  
    
  
  
  
    
    Sorry, something went wrong.
  

  
    
  
    
      

              Uh oh!

              
There was an error while loading. Please reload this page.


  
  


          
              
  
    
    
      
        
            
    All reactions
                 transformFlags |= TransformFlags.AssertTypeScript;
             }
-          Expand Down