From f6ac10958f4b68f217b130ccd786416fa6f00b9b Mon Sep 17 00:00:00 2001
From: Oleksandr T <oleksandr.tarasiuk@outlook.com>
Date: Wed, 20 Jul 2022 02:26:56 +0300
Subject: [PATCH] fix(49704): Code folding not working in file with simple
 syntax error (#49743)

* fix(49704): parse type arguments in super call expression

* omit duplicate errors
---
 src/compiler/checker.ts                               |  2 +-
 src/compiler/parser.ts                                |  5 ++++-
 .../reference/parserSuperExpression2.symbols          |  1 +
 .../baselines/reference/superWithTypeArgument.symbols |  1 +
 .../reference/superWithTypeArgument2.symbols          |  1 +
 .../reference/superWithTypeArgument3.symbols          |  1 +
 tests/cases/fourslash/getOutliningSpans.ts            | 11 ++++++++++-
 7 files changed, 19 insertions(+), 3 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 9bcb7dd2fa5..106142711d9 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -30780,7 +30780,7 @@ namespace ts {
 
             let typeArguments: NodeArray<TypeNode> | undefined;
 
-            if (!isDecorator) {
+            if (!isDecorator && !isSuperCall(node)) {
                 typeArguments = (node as CallExpression).typeArguments;
 
                 // We already perform checking on the type arguments on the class declaration itself.
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index f9aa3e57498..299a0fda38b 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -5285,12 +5285,15 @@ namespace ts {
 
         function parseSuperExpression(): MemberExpression {
             const pos = getNodePos();
-            const expression = parseTokenNode<PrimaryExpression>();
+            let expression = parseTokenNode<MemberExpression>();
             if (token() === SyntaxKind.LessThanToken) {
                 const startPos = getNodePos();
                 const typeArguments = tryParse(parseTypeArgumentsInExpression);
                 if (typeArguments !== undefined) {
                     parseErrorAt(startPos, getNodePos(), Diagnostics.super_may_not_use_type_arguments);
+                    if (!isTemplateStartOfTaggedTemplate()) {
+                        expression = factory.createExpressionWithTypeArguments(expression, typeArguments);
+                    }
                 }
             }
 
diff --git a/tests/baselines/reference/parserSuperExpression2.symbols b/tests/baselines/reference/parserSuperExpression2.symbols
index c382e54855f..47fff63acce 100644
--- a/tests/baselines/reference/parserSuperExpression2.symbols
+++ b/tests/baselines/reference/parserSuperExpression2.symbols
@@ -6,5 +6,6 @@ class C {
 >M : Symbol(C.M, Decl(parserSuperExpression2.ts, 0, 9))
 
     super<T>(0);
+>T : Symbol(T)
   }
 }
diff --git a/tests/baselines/reference/superWithTypeArgument.symbols b/tests/baselines/reference/superWithTypeArgument.symbols
index 50990b4817e..eeb5919958f 100644
--- a/tests/baselines/reference/superWithTypeArgument.symbols
+++ b/tests/baselines/reference/superWithTypeArgument.symbols
@@ -12,5 +12,6 @@ class D<T> extends C {
     constructor() {
         super<T>();
 >super : Symbol(C, Decl(superWithTypeArgument.ts, 0, 0))
+>T : Symbol(T, Decl(superWithTypeArgument.ts, 4, 8))
     }
 }
diff --git a/tests/baselines/reference/superWithTypeArgument2.symbols b/tests/baselines/reference/superWithTypeArgument2.symbols
index 35a371cde10..c42450e8723 100644
--- a/tests/baselines/reference/superWithTypeArgument2.symbols
+++ b/tests/baselines/reference/superWithTypeArgument2.symbols
@@ -19,6 +19,7 @@ class D<T> extends C<T> {
 
         super<T>(x);
 >super : Symbol(C, Decl(superWithTypeArgument2.ts, 0, 0))
+>T : Symbol(T, Decl(superWithTypeArgument2.ts, 4, 8))
 >x : Symbol(x, Decl(superWithTypeArgument2.ts, 5, 16))
     }
 }
diff --git a/tests/baselines/reference/superWithTypeArgument3.symbols b/tests/baselines/reference/superWithTypeArgument3.symbols
index a596264aa7d..9a6ff935961 100644
--- a/tests/baselines/reference/superWithTypeArgument3.symbols
+++ b/tests/baselines/reference/superWithTypeArgument3.symbols
@@ -23,6 +23,7 @@ class D<T> extends C<T> {
     constructor() {
         super<T>();
 >super : Symbol(C, Decl(superWithTypeArgument3.ts, 0, 0))
+>T : Symbol(T, Decl(superWithTypeArgument3.ts, 5, 8))
     }
     bar() {
 >bar : Symbol(D.bar, Decl(superWithTypeArgument3.ts, 8, 5))
diff --git a/tests/cases/fourslash/getOutliningSpans.ts b/tests/cases/fourslash/getOutliningSpans.ts
index a522d47ce8b..5d70c5c6dc7 100644
--- a/tests/cases/fourslash/getOutliningSpans.ts
+++ b/tests/cases/fourslash/getOutliningSpans.ts
@@ -114,6 +114,15 @@
 ////        2
 ////    ]|]
 ////)|];
-
+////
+////class C<T>[| {
+////    foo: T;
+////}|]
+////
+////class D<T> extends C<T>[| {
+////    constructor(x)[| {
+////        super<T>(x);
+////    }|]
+////}|]
 
 verify.outliningSpansInCurrentFile(test.ranges(), "code");