[SyntaxParse] Modify parseTypeCollection()

Now we always construct Array/DictionaryTypeSyntax even if ']' is missing.

Author: rintaro

lib/Parse/ASTGen.cpp

@@ -616,25 +616,37 @@ TypeRepr *ASTGen::generate(const DictionaryTypeSyntax &Type,
                            const SourceLoc Loc) {
   TypeRepr *ValueType = generate(Type.getValueType(), Loc);
   TypeRepr *KeyType = generate(Type.getKeyType(), Loc);
-  auto LBraceLoc = advanceLocBegin(Loc, Type.getLeftSquareBracket());
+  if (!ValueType || !KeyType)
+    return nullptr;
   auto ColonLoc = advanceLocBegin(Loc, Type.getColon());
-  auto RBraceLoc = advanceLocBegin(Loc, Type.getRightSquareBracket());
-  SourceRange Range{LBraceLoc, RBraceLoc};
+
+  SourceLoc LBracketLoc, RBracketLoc;
+  if (Type.getLeftSquareBracket().isPresent())
+    LBracketLoc = advanceLocBegin(Loc, Type.getLeftSquareBracket());
+  else
+    LBracketLoc = advanceLocBegin(Loc, *Type.getFirstToken());
+  if (Type.getRightSquareBracket().isPresent())
+    RBracketLoc = advanceLocBegin(Loc, Type.getRightSquareBracket());
+  else
+    RBracketLoc = advanceLocBegin(Loc, *Type.getLastToken());
+  SourceRange Range{LBracketLoc, RBracketLoc};
   return new (Context) DictionaryTypeRepr(KeyType, ValueType, ColonLoc, Range);
 }
 
 TypeRepr *ASTGen::generate(const ArrayTypeSyntax &Type, SourceLoc Loc) {
   TypeRepr *ElementType = generate(Type.getElementType(), Loc);
-  SourceLoc LBraceLoc, RBraceLoc;
+  if (!ElementType)
+    return nullptr;
+  SourceLoc LBracketLoc, RBracketLoc;
   if (Type.getLeftSquareBracket().isPresent())
-    LBraceLoc = advanceLocBegin(Loc, Type.getLeftSquareBracket());
+    LBracketLoc = advanceLocBegin(Loc, Type.getLeftSquareBracket());
   else
-    LBraceLoc = advanceLocBegin(Loc, Type.getElementType());
-  if (Type.getLeftSquareBracket().isPresent())
-    RBraceLoc = advanceLocBegin(Loc, Type.getRightSquareBracket());
+    LBracketLoc = advanceLocBegin(Loc, *Type.getFirstToken());
+  if (Type.getRightSquareBracket().isPresent())
+    RBracketLoc = advanceLocBegin(Loc, Type.getRightSquareBracket());
   else
-    RBraceLoc = advanceLocBegin(Loc, *Type.getLastToken());
-  return new (Context) ArrayTypeRepr(ElementType, {LBraceLoc, RBraceLoc});
+    RBracketLoc = advanceLocBegin(Loc, *Type.getLastToken());
+  return new (Context) ArrayTypeRepr(ElementType, {LBracketLoc, RBracketLoc});
 }
 
 TypeRepr *ASTGen::generate(const MetatypeTypeSyntax &Type,

lib/Parse/ParseType.cpp

@@ -1276,51 +1276,48 @@ ParsedSyntaxResult<ParsedTypeSyntax> Parser::parseTypeCollection() {
   auto ElementTypeResult = parseTypeSyntax(diag::expected_element_type);
   Status |= ElementTypeResult.getStatus();
   auto ElementType = ElementTypeResult.getOrNull();
+  if (!ElementType)
+    ElementType = ParsedSyntaxRecorder::makeUnknownType({}, *SyntaxContext);
 
   Optional<ParsedTokenSyntax> Colon;
   Optional<ParsedTypeSyntax> ValueType;
 
   if (Tok.is(tok::colon)) {
     Colon = consumeTokenSyntax(tok::colon);
-    auto ValueTypeResult = parseTypeSyntax(diag::expected_dictionary_value_type);
+    auto ValueTypeResult =
+        parseTypeSyntax(diag::expected_dictionary_value_type);
     ValueType = ValueTypeResult.getOrNull();
+    if (!ValueType)
+      ValueType = ParsedSyntaxRecorder::makeUnknownType({}, *SyntaxContext);
     Status |= ValueTypeResult.getStatus();
   }
 
   auto Diag = Colon ? diag::expected_rbracket_dictionary_type
                     : diag::expected_rbracket_array_type;
 
   SourceLoc RSquareLoc;
-  auto RSquare = parseMatchingTokenSyntax(tok::r_square, RSquareLoc, Diag,
-                                          LSquareLoc);
+  auto RSquare =
+      parseMatchingTokenSyntax(tok::r_square, RSquareLoc, Diag, LSquareLoc);
   if (!RSquare)
     Status.setIsParseError();
 
-  if (!Status.isSuccess()) {
-    SmallVector<ParsedSyntax, 0> Pieces;
-    Pieces.push_back(std::move(LSquare));
-    if (ElementType)
-      Pieces.push_back(std::move(*ElementType));
-    if (Colon)
-      Pieces.push_back(std::move(*Colon));
-    if (ValueType)
-      Pieces.push_back(std::move(*ValueType));
+  if (Colon) {
+    ParsedDictionaryTypeSyntaxBuilder builder(*SyntaxContext);
+    builder.useLeftSquareBracket(std::move(LSquare));
+    builder.useKeyType(std::move(*ElementType));
+    builder.useColon(std::move(*Colon));
+    builder.useValueType(std::move(*ValueType));
     if (RSquare)
-      Pieces.push_back(std::move(*RSquare));
-
-    ParsedTypeSyntax ty =
-        ParsedSyntaxRecorder::makeUnknownType(Pieces, *SyntaxContext);
-    return makeParsedResult(std::move(ty), Status);
+      builder.useRightSquareBracket(std::move(*RSquare));
+    return makeParsedResult(builder.build(), Status);
+  } else {
+    ParsedArrayTypeSyntaxBuilder builder(*SyntaxContext);
+    builder.useLeftSquareBracket(std::move(LSquare));
+    builder.useElementType(std::move(*ElementType));
+    if (RSquare)
+      builder.useRightSquareBracket(std::move(*RSquare));
+    return makeParsedResult(builder.build(), Status);
   }
-
-  if (Colon)
-    return makeParsedResult(ParsedSyntaxRecorder::makeDictionaryType(
-        std::move(LSquare), std::move(*ElementType), std::move(*Colon),
-        std::move(*ValueType), std::move(*RSquare), *SyntaxContext));
-
-  return makeParsedResult(ParsedSyntaxRecorder::makeArrayType(
-      std::move(LSquare), std::move(*ElementType), std::move(*RSquare),
-      *SyntaxContext));
 }
 
 ParsedSyntaxResult<ParsedTypeSyntax>

test/Syntax/Outputs/round_trip_invalid.swift.withkinds

@@ -9,7 +9,7 @@
 // RUN: %swift-syntax-test -deserialize-raw-tree -input-source-filename %t.dump -output-filename %t
 // RUN: diff -u %s %t
 
-let <PatternBinding><IdentifierPattern>strings</IdentifierPattern><TypeAnnotation>: [<ArrayType><SimpleTypeIdentifier>Strin</SimpleTypeIdentifier></ArrayType></TypeAnnotation></PatternBinding></VariableDecl><IdentifierExpr>[g</IdentifierExpr>]?<FunctionDecl>
+let <PatternBinding><IdentifierPattern>strings</IdentifierPattern><TypeAnnotation>: <ArrayType>[<ArrayType><SimpleTypeIdentifier>Strin</SimpleTypeIdentifier></ArrayType></ArrayType></TypeAnnotation></PatternBinding></VariableDecl><IdentifierExpr>[g</IdentifierExpr>]?<FunctionDecl>
 
 // Function body without closing brace token.
 func foo<FunctionSignature><ParameterClause>() </ParameterClause></FunctionSignature><CodeBlock>{<VariableDecl>