Instantiation expression can be followed by line break or binary operator

src/compiler/parser.ts

@@ -5732,6 +5732,12 @@ namespace ts {
                 case SyntaxKind.NoSubstitutionTemplateLiteral:  // foo<T> `...`
                 case SyntaxKind.TemplateHead:                   // foo<T> `...${100}...`
                     return true;
+                // These strict mode reserved words are valid identifiers in non-strict mode, and can thus
+                // start an expression. However, when they follow a type argument list and are immediately
+                // preceded by a line break, we don't consider them expression starters.
+                case SyntaxKind.InterfaceKeyword:
+                case SyntaxKind.LetKeyword:
+                    return scanner.hasPrecedingLineBreak();
             }
             // Consider something a type argument list only if the following token can't start an expression.
             return !isStartOfExpression();

tests/baselines/reference/instantiationExpressionErrors.errors.txt

@@ -77,4 +77,14 @@ tests/cases/conformance/types/typeParameters/typeArgumentLists/instantiationExpr
 
     const x4 = f<true>
     if (true) {}
+
+    // Parsed as instantiation expression
+
+    const x5 = f<true>
+    let yy = 0;
+
+    // Parsed as instantiation expression
+
+    const x6 = f<true>
+    interface I {}
 

tests/baselines/reference/instantiationExpressionErrors.js

@@ -45,6 +45,16 @@ true;
 
 const x4 = f<true>
 if (true) {}
+
+// Parsed as instantiation expression
+
+const x5 = f<true>
+let yy = 0;
+
+// Parsed as instantiation expression
+
+const x6 = f<true>
+interface I {}
 
 
 //// [instantiationExpressionErrors.js]
@@ -78,6 +88,11 @@ true;
 // Parsed as instantiation expression
 var x4 = (f);
 if (true) { }
+// Parsed as instantiation expression
+var x5 = (f);
+var yy = 0;
+// Parsed as instantiation expression
+var x6 = (f);
 
 
 //// [instantiationExpressionErrors.d.ts]
@@ -113,3 +128,14 @@ declare const x4: {
     (): true;
     g<U>(): U;
 };
+declare const x5: {
+    (): true;
+    g<U>(): U;
+};
+declare let yy: number;
+declare const x6: {
+    (): true;
+    g<U>(): U;
+};
+interface I {
+}

tests/baselines/reference/instantiationExpressionErrors.symbols

@@ -107,3 +107,21 @@ const x4 = f<true>
 
 if (true) {}
 
+// Parsed as instantiation expression
+
+const x5 = f<true>
+>x5 : Symbol(x5, Decl(instantiationExpressionErrors.ts, 49, 5))
+>f : Symbol(f, Decl(instantiationExpressionErrors.ts, 0, 11))
+
+let yy = 0;
+>yy : Symbol(yy, Decl(instantiationExpressionErrors.ts, 50, 3))
+
+// Parsed as instantiation expression
+
+const x6 = f<true>
+>x6 : Symbol(x6, Decl(instantiationExpressionErrors.ts, 54, 5))
+>f : Symbol(f, Decl(instantiationExpressionErrors.ts, 0, 11))
+
+interface I {}
+>I : Symbol(I, Decl(instantiationExpressionErrors.ts, 54, 18))
+

tests/baselines/reference/instantiationExpressionErrors.types

@@ -132,3 +132,23 @@ const x4 = f<true>
 if (true) {}
 >true : true
 
+// Parsed as instantiation expression
+
+const x5 = f<true>
+>x5 : { (): true; g<U>(): U; }
+>f : { <T>(): T; g<U>(): U; }
+>true : true
+
+let yy = 0;
+>yy : number
+>0 : 0
+
+// Parsed as instantiation expression
+
+const x6 = f<true>
+>x6 : { (): true; g<U>(): U; }
+>f : { <T>(): T; g<U>(): U; }
+>true : true
+
+interface I {}
+

tests/cases/conformance/types/typeParameters/typeArgumentLists/instantiationExpressionErrors.ts

@@ -47,3 +47,13 @@ true;
 
 const x4 = f<true>
 if (true) {}
+
+// Parsed as instantiation expression
+
+const x5 = f<true>
+let yy = 0;
+
+// Parsed as instantiation expression
+
+const x6 = f<true>
+interface I {}