Parser: recover on missing types in tuple and function types

src/Compiler/FSComp.txt

@@ -1684,4 +1684,5 @@ featureEscapeBracesInFormattableString,"Escapes curly braces before calling Form
 3560,tcCopyAndUpdateRecordChangesAllFields,"This copy-and-update record expression changes all fields of record type '%s'. Consider using the record construction syntax instead."
 3561,chkAutoOpenAttributeInTypeAbbrev,"FSharp.Core.AutoOpenAttribute should not be aliased."
 3562,parsUnexpectedEndOfFileElif,"Unexpected end of input in 'else if' or 'elif' branch of conditional expression. Expected 'elif <expr> then <expr>' or 'else if <expr> then <expr>'."
-3563,lexInvalidIdentifier,"This is not a valid identifier"
+3563,lexInvalidIdentifier,"This is not a valid identifier"
+3565,parsExpectingType,"Expecting type"

src/Compiler/pars.fsy

@@ -5139,32 +5139,64 @@ opt_topReturnTypeWithTypeConstraints:
         let ty, arity = SynType.FromParseError(mColon.EndRange), SynInfo.unnamedRetVal
         Some (Some mColon, SynReturnInfo((ty, arity), mColon.EndRange)) }
 
-topType: 
-  | topTupleType RARROW topType 
-     { let dty, dmdata= $1 
-       let rty, (SynValInfo(dmdatas, rmdata)) = $3
+topType:
+  | topTupleType RARROW topType
+      { let dty, dmdata = $1
+        let rty, (SynValInfo(dmdatas, rmdata)) = $3
+        let mArrow = rhs parseState 2
+        SynType.Fun(dty, rty, lhs parseState, { ArrowRange = mArrow }), SynValInfo(dmdata :: dmdatas, rmdata) }
+
+  | topTupleType RARROW recover
+     { let dty, dmdata = $1
        let mArrow = rhs parseState 2
-       SynType.Fun(dty, rty, lhs parseState, { ArrowRange = mArrow }), (SynValInfo(dmdata :: dmdatas, rmdata)) }
+       let rty = SynType.FromParseError(mArrow.EndRange)
+       SynType.Fun(dty, rty, lhs parseState, { ArrowRange = mArrow }), SynValInfo([dmdata], SynInfo.unnamedRetVal) }
 
   | topTupleType 
      { let ty, rmdata = $1 in ty, (SynValInfo([], (match rmdata with [md] -> md | _ -> SynInfo.unnamedRetVal))) }
 
 topTupleType:
-  | topAppType STAR topTupleTypeElements 
-     { let t, argInfo = $1
+  | topAppType STAR topTupleTypeElements
+      { let t, argInfo = $1
+        let mStar = rhs parseState 2
+        let path = SynTupleTypeSegment.Type t :: SynTupleTypeSegment.Star mStar :: (List.map fst $3)
+        let mdata = argInfo :: (List.choose snd $3)
+        mkSynTypeTuple path, mdata }
+
+  | topAppType STAR recover
+     { let ty1, argInfo = $1
        let mStar = rhs parseState 2
-       let path = SynTupleTypeSegment.Type t :: SynTupleTypeSegment.Star mStar :: (List.map fst $3)
-       let mdata = argInfo :: (List.choose snd $3)
-       mkSynTypeTuple path, mdata }
+       let ty2 = SynType.FromParseError(mStar.EndRange)
+       let path = [SynTupleTypeSegment.Type ty1; SynTupleTypeSegment.Star mStar; SynTupleTypeSegment.Type ty2]
+       mkSynTypeTuple path, [argInfo] }
+
+  | STAR topTupleTypeElements
+      { let mStar = rhs parseState 1
+        let ty = SynType.FromParseError(mStar.EndRange)
+        reportParseErrorAt mStar (FSComp.SR.parsExpectingType ())
+        let path = SynTupleTypeSegment.Type ty :: SynTupleTypeSegment.Star mStar :: (List.map fst $2)
+        mkSynTypeTuple path, List.choose snd $2 }
 
   | topAppType                 
      { let ty, mdata = $1 in ty, [mdata] }
 
 topTupleTypeElements:
-  | topAppType STAR topTupleTypeElements       
-     { let t, argInfo = $1
-       let mStar = rhs parseState 2
-       (SynTupleTypeSegment.Type t, Some argInfo) :: (SynTupleTypeSegment.Star mStar, None) :: $3 }
+  | topAppType STAR topTupleTypeElements
+      { let t, argInfo = $1
+        let mStar = rhs parseState 2
+        (SynTupleTypeSegment.Type t, Some argInfo) :: (SynTupleTypeSegment.Star mStar, None) :: $3 }
+
+  | topAppType STAR recover
+      { let ty1, argInfo = $1
+        let mStar = rhs parseState 2
+        let ty2 = SynType.FromParseError(mStar.EndRange)
+        [(SynTupleTypeSegment.Type ty1, Some argInfo); (SynTupleTypeSegment.Star mStar, None); (SynTupleTypeSegment.Type ty2, None)] }
+
+  | STAR topTupleTypeElements
+      { let mStar = rhs parseState 1
+        let ty = SynType.FromParseError(mStar.EndRange)
+        reportParseErrorAt mStar (FSComp.SR.parsExpectingType ())
+        (SynTupleTypeSegment.Type ty, None) :: (SynTupleTypeSegment.Star mStar, None) :: $2 }
 
   | topAppType %prec prec_toptuptyptail_prefix 
      { let t, argInfo = $1
@@ -5233,50 +5265,117 @@ topAppType:
 /* Any tokens in this grammar must be added to the lex filter rule 'peekAdjacentTypars' */
 /* See the F# specification "Lexical analysis of type applications and type parameter definitions" */
 typ:
-  | tupleType RARROW typ  
-     { let mArrow = rhs parseState 2
-       SynType.Fun($1, $3, lhs parseState, { ArrowRange = mArrow }) }
-
-  | tupleType %prec prec_typ_prefix 
-     { $1 }
+  | tupleType RARROW typ
+      { let mArrow = rhs parseState 2
+        let m = unionRanges (rhs2 parseState 1 2) $3.Range
+        SynType.Fun($1, $3, m, { ArrowRange = mArrow }) }
+
+  | tupleType RARROW recover
+      { let mArrow = rhs parseState 2
+        let ty = SynType.FromParseError(mArrow.EndRange)
+        let m = rhs2 parseState 1 2
+        SynType.Fun($1, ty, m, { ArrowRange = mArrow }) }
+
+  | tupleType RARROW RARROW typ
+      { let mArrow1 = rhs parseState 2
+        let mArrow2 = rhs parseState 3
+        reportParseErrorAt mArrow2 (FSComp.SR.parsExpectingType ())
+        let ty = SynType.FromParseError(mArrow2.StartRange)
+        let m1 = unionRanges $1.Range $4.Range
+        let m2 = unionRanges mArrow2 $4.Range
+        SynType.Fun($1, SynType.Fun(ty, $4, m2, { ArrowRange = mArrow2 }), m1, { ArrowRange = mArrow1 }) }
+
+  | tupleType %prec prec_typ_prefix
+      { $1 }
 
 typEOF:
   | typ EOF { checkEndOfFileError $2; $1 }
 
 
 tupleType:
-  | appType STAR tupleOrQuotTypeElements 
-    { let mStar = rhs parseState 2
-      let path = SynTupleTypeSegment.Type $1 :: SynTupleTypeSegment.Star mStar :: $3
-      mkSynTypeTuple path }
+  | appType STAR tupleOrQuotTypeElements
+      { let mStar = rhs parseState 2
+        let path = SynTupleTypeSegment.Type $1 :: SynTupleTypeSegment.Star mStar :: $3
+        mkSynTypeTuple path }
+
+  | appType STAR recover
+      { let mStar = rhs parseState 2
+        let ty = SynType.FromParseError(mStar.EndRange)
+        let path = [SynTupleTypeSegment.Type $1; SynTupleTypeSegment.Star mStar; SynTupleTypeSegment.Type ty]
+        mkSynTypeTuple path }
+
+  | STAR tupleOrQuotTypeElements
+      { let mStar = rhs parseState 1
+        let ty = SynType.FromParseError(mStar.EndRange)
+        reportParseErrorAt mStar (FSComp.SR.parsExpectingType ())
+        let path = SynTupleTypeSegment.Type ty :: SynTupleTypeSegment.Star mStar :: $2
+        mkSynTypeTuple path }
 
   | INFIX_STAR_DIV_MOD_OP tupleOrQuotTypeElements
-    { if $1 <> "/" then reportParseErrorAt (rhs parseState 1) (FSComp.SR.parsUnexpectedInfixOperator());
-      let mSlash = rhs parseState 1
-      let path = SynTupleTypeSegment.Slash mSlash :: $2
-      mkSynTypeTuple path }
+      { if $1 <> "/" then reportParseErrorAt (rhs parseState 1) (FSComp.SR.parsUnexpectedInfixOperator ())
+        let mSlash = rhs parseState 1
+        let path = SynTupleTypeSegment.Slash mSlash :: $2
+        mkSynTypeTuple path }
+
+  | INFIX_STAR_DIV_MOD_OP recover
+      { if $1 <> "/" then reportParseErrorAt (rhs parseState 1) (FSComp.SR.parsUnexpectedInfixOperator ())
+        let mSlash = rhs parseState 1
+        let ty = SynType.FromParseError(mSlash.EndRange)
+        let path = [SynTupleTypeSegment.Slash mSlash; SynTupleTypeSegment.Type ty]
+        mkSynTypeTuple path }
 
   | appType INFIX_STAR_DIV_MOD_OP tupleOrQuotTypeElements
-    { if $2 <> "/" then reportParseErrorAt (rhs parseState 1) (FSComp.SR.parsUnexpectedInfixOperator());
-      let mSlash = rhs parseState 2
-      let path = SynTupleTypeSegment.Type $1 :: SynTupleTypeSegment.Slash mSlash :: $3
-      mkSynTypeTuple path }
-
-  | appType %prec prec_tuptyp_prefix 
-    { $1 }
+      { if $2 <> "/" then reportParseErrorAt (rhs parseState 1) (FSComp.SR.parsUnexpectedInfixOperator())
+        let mSlash = rhs parseState 2
+        let path = SynTupleTypeSegment.Type $1 :: SynTupleTypeSegment.Slash mSlash :: $3
+        mkSynTypeTuple path }
+
+  | appType INFIX_STAR_DIV_MOD_OP recover
+      { if $2 <> "/" then reportParseErrorAt (rhs parseState 1) (FSComp.SR.parsUnexpectedInfixOperator ())
+        let mSlash = rhs parseState 2
+        let ty = SynType.FromParseError(mSlash.EndRange)
+        let path = [SynTupleTypeSegment.Type $1; SynTupleTypeSegment.Slash mSlash; SynTupleTypeSegment.Type ty]
+        mkSynTypeTuple path }
+
+  | appType %prec prec_tuptyp_prefix
+      { $1 }
 
 tupleOrQuotTypeElements:
-  | appType STAR tupleOrQuotTypeElements              
-    { let mStar = rhs parseState 2
-      SynTupleTypeSegment.Type $1 :: SynTupleTypeSegment.Star mStar :: $3 }
+  | appType STAR tupleOrQuotTypeElements
+      { let mStar = rhs parseState 2
+        SynTupleTypeSegment.Type $1 :: SynTupleTypeSegment.Star mStar :: $3 }
+
+  | appType STAR recover
+      { let mStar = rhs parseState 2
+        let ty = SynType.FromParseError(mStar.EndRange)
+        [SynTupleTypeSegment.Type $1; SynTupleTypeSegment.Star mStar; SynTupleTypeSegment.Type ty] }
 
-  | appType INFIX_STAR_DIV_MOD_OP tupleOrQuotTypeElements 
-    { if $2 <> "/" then reportParseErrorAt (rhs parseState 1) (FSComp.SR.parsUnexpectedInfixOperator());
-      let mSlash = rhs parseState 2
-      SynTupleTypeSegment.Type $1 :: SynTupleTypeSegment.Slash mSlash :: $3 }
+  | STAR tupleOrQuotTypeElements
+      { let mStar = rhs parseState 1
+        let ty = SynType.FromParseError(mStar.EndRange)
+        reportParseErrorAt mStar (FSComp.SR.parsExpectingType ())
+        SynTupleTypeSegment.Type ty :: SynTupleTypeSegment.Star mStar :: $2 }
 
-  | appType %prec prec_tuptyptail_prefix 
-    { [ SynTupleTypeSegment.Type $1 ] }
+  | appType INFIX_STAR_DIV_MOD_OP tupleOrQuotTypeElements
+      { if $2 <> "/" then reportParseErrorAt (rhs parseState 1) (FSComp.SR.parsUnexpectedInfixOperator ())
+        let mSlash = rhs parseState 2
+        SynTupleTypeSegment.Type $1 :: SynTupleTypeSegment.Slash mSlash :: $3 }
+
+  | appType INFIX_STAR_DIV_MOD_OP recover
+      { if $2 <> "/" then reportParseErrorAt (rhs parseState 1) (FSComp.SR.parsUnexpectedInfixOperator ())
+        let mSlash = rhs parseState 2
+        let ty = SynType.FromParseError(mSlash.EndRange)
+        [SynTupleTypeSegment.Type $1; SynTupleTypeSegment.Slash mSlash; SynTupleTypeSegment.Type ty] }
+
+  | INFIX_STAR_DIV_MOD_OP tupleOrQuotTypeElements
+      { if $1 <> "/" then reportParseErrorAt (rhs parseState 1) (FSComp.SR.parsUnexpectedInfixOperator ())
+        let mSlash = rhs parseState 1
+        let ty = SynType.FromParseError(mSlash.EndRange)
+        reportParseErrorAt mSlash (FSComp.SR.parsExpectingType ())
+        SynTupleTypeSegment.Type ty :: SynTupleTypeSegment.Slash mSlash :: $2 }
+
+  | appType %prec prec_tuptyptail_prefix
+      { [ SynTupleTypeSegment.Type $1 ] }
 
 appTypeCon:
   | path %prec prec_atomtyp_path 

src/Compiler/xlf/FSComp.txt.cs.xlf

@@ -762,6 +762,11 @@
         <target state="translated">Očekává se vzorek.</target>
         <note />
       </trans-unit>
+      <trans-unit id="parsExpectingType">
+        <source>Expecting type</source>
+        <target state="new">Expecting type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr1">
         <source>Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</source>
         <target state="translated">Neúplný znakový literál (příklad: Q) nebo volání kvalifikovaného typu (příklad: T.Name)</target>

src/Compiler/xlf/FSComp.txt.de.xlf

@@ -762,6 +762,11 @@
         <target state="translated">Muster wird erwartet</target>
         <note />
       </trans-unit>
+      <trans-unit id="parsExpectingType">
+        <source>Expecting type</source>
+        <target state="new">Expecting type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr1">
         <source>Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</source>
         <target state="translated">Unvollständiges Zeichenliteral (Beispiel: „Q“) oder qualifizierter Typaufruf (Beispiel: „T.Name“)</target>

src/Compiler/xlf/FSComp.txt.es.xlf

@@ -762,6 +762,11 @@
         <target state="translated">Se espera un patrón</target>
         <note />
       </trans-unit>
+      <trans-unit id="parsExpectingType">
+        <source>Expecting type</source>
+        <target state="new">Expecting type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr1">
         <source>Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</source>
         <target state="translated">Literal de carácter incompleto (ejemplo: 'Q') o invocación de tipo completo (ejemplo: 'T.Name)</target>

src/Compiler/xlf/FSComp.txt.fr.xlf

@@ -762,6 +762,11 @@
         <target state="translated">Modèle attendu</target>
         <note />
       </trans-unit>
+      <trans-unit id="parsExpectingType">
+        <source>Expecting type</source>
+        <target state="new">Expecting type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr1">
         <source>Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</source>
         <target state="translated">Littéral de caractère incomplet (exemple : 'Q') ou appel de type qualifié (exemple : 'T.Name)</target>

src/Compiler/xlf/FSComp.txt.it.xlf

@@ -762,6 +762,11 @@
         <target state="translated">Criterio previsto</target>
         <note />
       </trans-unit>
+      <trans-unit id="parsExpectingType">
+        <source>Expecting type</source>
+        <target state="new">Expecting type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr1">
         <source>Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</source>
         <target state="translated">Valore letterale carattere incompleto (ad esempio: 'Q') o chiamata di tipo qualificato (ad esempio: 'T.Name)</target>

src/Compiler/xlf/FSComp.txt.ja.xlf

@@ -762,6 +762,11 @@
         <target state="translated">必要なパターン</target>
         <note />
       </trans-unit>
+      <trans-unit id="parsExpectingType">
+        <source>Expecting type</source>
+        <target state="new">Expecting type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr1">
         <source>Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</source>
         <target state="translated">不完全な文字リテラル (例: 'Q') または修飾型の呼び出し (例: 'T.Name)</target>

src/Compiler/xlf/FSComp.txt.ko.xlf

@@ -762,6 +762,11 @@
         <target state="translated">예상되는 패턴</target>
         <note />
       </trans-unit>
+      <trans-unit id="parsExpectingType">
+        <source>Expecting type</source>
+        <target state="new">Expecting type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr1">
         <source>Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</source>
         <target state="translated">불완전한 문자 리터럴(예: 'Q') 또는 정규화된 형식 호출(예: 'T.Name)</target>

src/Compiler/xlf/FSComp.txt.pl.xlf

@@ -762,6 +762,11 @@
         <target state="translated">Oczekiwano wzorca</target>
         <note />
       </trans-unit>
+      <trans-unit id="parsExpectingType">
+        <source>Expecting type</source>
+        <target state="new">Expecting type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr1">
         <source>Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</source>
         <target state="translated">Niekompletny literał znaku (przykład: „Q”) lub wywołanie typu kwalifikowanego (przykład: „T.Name”)</target>

src/Compiler/xlf/FSComp.txt.pt-BR.xlf

@@ -762,6 +762,11 @@
         <target state="translated">Padrão esperado</target>
         <note />
       </trans-unit>
+      <trans-unit id="parsExpectingType">
+        <source>Expecting type</source>
+        <target state="new">Expecting type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr1">
         <source>Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</source>
         <target state="translated">Literal de caractere incompleto (exemplo: 'Q') ou invocação de tipo qualificado (exemplo: 'T.Name)</target>

src/Compiler/xlf/FSComp.txt.ru.xlf

@@ -762,6 +762,11 @@
         <target state="translated">Ожидается шаблон</target>
         <note />
       </trans-unit>
+      <trans-unit id="parsExpectingType">
+        <source>Expecting type</source>
+        <target state="new">Expecting type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr1">
         <source>Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</source>
         <target state="translated">Неполный символьный литерал (например: "Q") или вызов квалифицированного типа (например: "T.Name)</target>

src/Compiler/xlf/FSComp.txt.tr.xlf

@@ -762,6 +762,11 @@
         <target state="translated">Desen bekleniyor</target>
         <note />
       </trans-unit>
+      <trans-unit id="parsExpectingType">
+        <source>Expecting type</source>
+        <target state="new">Expecting type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr1">
         <source>Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</source>
         <target state="translated">Eksik karakter değişmez değeri (örnek: 'Q') veya tam tür çağrısı (örnek: 'T.Name)</target>

src/Compiler/xlf/FSComp.txt.zh-Hans.xlf

@@ -762,6 +762,11 @@
         <target state="translated">预期模式</target>
         <note />
       </trans-unit>
+      <trans-unit id="parsExpectingType">
+        <source>Expecting type</source>
+        <target state="new">Expecting type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr1">
         <source>Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</source>
         <target state="translated">字符文本不完整(示例: "Q")或限定类型调用(示例: "T.Name")</target>

src/Compiler/xlf/FSComp.txt.zh-Hant.xlf

@@ -762,6 +762,11 @@
         <target state="translated">必須是模式</target>
         <note />
       </trans-unit>
+      <trans-unit id="parsExpectingType">
+        <source>Expecting type</source>
+        <target state="new">Expecting type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr1">
         <source>Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</source>
         <target state="translated">不完整的字元文字 (範例: 'Q') 或限定類型調用 (範例: 'T.Name)</target>

tests/fsharpqa/Source/Diagnostics/NONTERM/typ01.fs

@@ -1,6 +1,6 @@
 // #Regression #Diagnostics 
 // Regression test for FSHARP1.0:2467
-//<Expects id="FS0010" span="(9,115-9,117)" status="error">Unexpected symbol '->' in type</Expects>
+//<Expects id="FS3565" span="(9,115-9,117)" status="error">Expecting type</Expects>
 
 #light