Fix qualified name parsing syntax verification errors.

Author: dan-zheng

lib/Parse/ParseDecl.cpp

@@ -1093,22 +1093,23 @@ bool Parser::parseDifferentiableAttributeArguments(
 static bool parseBaseTypeForQualifiedDeclName(Parser &P, TypeRepr *&baseType) {
   baseType = nullptr;
 
+  // If base type cannot be parsed, return false (no error).
   if (!P.canParseBaseTypeForQualifiedDeclName())
     return false;
 
   auto result = P.parseTypeIdentifier(/*isParsingQualifiedDeclName*/ true);
+  // If base type should be parseable but the actual base type result is null,
+  // return true (error).
   if (result.isNull())
     return true;
 
-  // Consume a leading period. This is relevant only for qualified operators.
-  // TODO(TF-1065): Consider disallowing qualified operator names. There is no
-  // precedent for qualified operator syntax elsewhere in Swift.
-  if (P.startsWithSymbol(P.Tok, '.')) {
-    assert(P.Tok.isAnyOperator() &&
-           "Only operators should have leading period here");
-    P.consumeStartingCharacterOfCurrentToken(tok::period);
-  }
+  // Consume the leading period before the final declaration name component.
+  // `parseTypeIdentifier(/*isParsingQualifiedDeclName*/ true)` leaves the
+  // leading period unparsed to avoid syntax verification errors.
+  assert(P.startsWithSymbol(P.Tok, '.') && "false");
+  P.consumeStartingCharacterOfCurrentToken(tok::period);
 
+  // Set base type and return false (no error).
   baseType = result.getPtrOrNull();
   return false;
 }

lib/Parse/ParseType.cpp

@@ -734,18 +734,19 @@ Parser::parseTypeIdentifier(bool isParsingQualifiedDeclBaseType) {
       }
       if (!peekToken().isContextualKeyword("Type")
           && !peekToken().isContextualKeyword("Protocol")) {
-        // Consume the period.
-        consumeToken();
         // If parsing a qualified declaration name, break before parsing the
-        // final declaration name component.
+        // period before the final declaration name component.
         if (isParsingQualifiedDeclBaseType) {
-          BacktrackingScope backtrack(*this);
           // If qualified name base type cannot be parsed from the current
           // point (i.e. the next type identifier is not followed by a '.'),
           // then the next identifier is the final declaration name component.
+          BacktrackingScope backtrack(*this);
+          consumeStartingCharacterOfCurrentToken(tok::period);
           if (!canParseBaseTypeForQualifiedDeclName())
             break;
         }
+        // Consume the period.
+        consumeToken();
         continue;
       }
     } else if (Tok.is(tok::code_complete)) {

test/AutoDiff/Syntax/Outputs/round_trip_parse_gen.swift.withkinds

@@ -50,6 +50,12 @@ func bazDerivative<FunctionSignature><ParameterClause>(<FunctionParameter>_ x: <
   return <TupleExpr>(<TupleExprElement><IdentifierExpr>x</IdentifierExpr>, </TupleExprElement><TupleExprElement><ClosureExpr>{ <ClosureSignature><ClosureParam>v </ClosureParam>in </ClosureSignature><IdentifierExpr>v </IdentifierExpr>}</ClosureExpr></TupleExprElement>)</TupleExpr></ReturnStmt>
 }</CodeBlock></FunctionDecl><FunctionDecl><Attribute>
 
+@derivative(<DerivativeRegistrationAttributeArguments>of: <QualifiedDeclName><MemberTypeIdentifier><MemberTypeIdentifier><SimpleTypeIdentifier>A</SimpleTypeIdentifier>.B</MemberTypeIdentifier>.C</MemberTypeIdentifier>.foo<DeclNameArguments>(<DeclNameArgument>label:</DeclNameArgument><DeclNameArgument>_:</DeclNameArgument>)</DeclNameArguments></QualifiedDeclName>, <DifferentiationParamsClause>wrt: <DifferentiationParams>(<DifferentiationParam>x</DifferentiationParam>)</DifferentiationParams></DifferentiationParamsClause></DerivativeRegistrationAttributeArguments>)</Attribute>
+func qualifiedDerivative<FunctionSignature><ParameterClause>(<FunctionParameter>_ x: <SimpleTypeIdentifier>Float</SimpleTypeIdentifier>, </FunctionParameter><FunctionParameter>y: <SimpleTypeIdentifier>Float</SimpleTypeIdentifier></FunctionParameter>)</ParameterClause><ReturnClause>
+    -> <TupleType>(<TupleTypeElement>value: <SimpleTypeIdentifier>Float</SimpleTypeIdentifier>, </TupleTypeElement><TupleTypeElement>pullback: <FunctionType>(<TupleTypeElement><SimpleTypeIdentifier>Float</SimpleTypeIdentifier></TupleTypeElement>) -> <SimpleTypeIdentifier>Float</SimpleTypeIdentifier></FunctionType></TupleTypeElement>) </TupleType></ReturnClause></FunctionSignature><CodeBlock>{<ReturnStmt>
+  return <TupleExpr>(<TupleExprElement><IdentifierExpr>x</IdentifierExpr>, </TupleExprElement><TupleExprElement><ClosureExpr>{ <ClosureSignature><ClosureParam>v </ClosureParam>in </ClosureSignature><IdentifierExpr>v </IdentifierExpr>}</ClosureExpr></TupleExprElement>)</TupleExpr></ReturnStmt>
+}</CodeBlock></FunctionDecl><FunctionDecl><Attribute>
+
 @transpose(<DerivativeRegistrationAttributeArguments>of: <QualifiedDeclName>+</QualifiedDeclName></DerivativeRegistrationAttributeArguments>)</Attribute>
 func addTranspose<FunctionSignature><ParameterClause>(<FunctionParameter>_ v: <SimpleTypeIdentifier>Float</SimpleTypeIdentifier></FunctionParameter>) </ParameterClause><ReturnClause>-> <TupleType>(<TupleTypeElement><SimpleTypeIdentifier>Float</SimpleTypeIdentifier>, </TupleTypeElement><TupleTypeElement><SimpleTypeIdentifier>Float</SimpleTypeIdentifier></TupleTypeElement>) </TupleType></ReturnClause></FunctionSignature><CodeBlock>{<ReturnStmt>
   return <TupleExpr>(<TupleExprElement><IdentifierExpr>v</IdentifierExpr>, </TupleExprElement><TupleExprElement><IdentifierExpr>v</IdentifierExpr></TupleExprElement>)</TupleExpr></ReturnStmt>
@@ -58,4 +64,14 @@ func addTranspose<FunctionSignature><ParameterClause>(<FunctionParameter>_ v: <S
 @transpose(<DerivativeRegistrationAttributeArguments>of: <QualifiedDeclName>-</QualifiedDeclName>, <DifferentiationParamsClause>wrt: <DifferentiationParams>(<DifferentiationParam>0, </DifferentiationParam><DifferentiationParam>1</DifferentiationParam>)</DifferentiationParams></DifferentiationParamsClause></DerivativeRegistrationAttributeArguments>)</Attribute>
 func subtractTranspose<FunctionSignature><ParameterClause>(<FunctionParameter>_ v: <SimpleTypeIdentifier>Float</SimpleTypeIdentifier></FunctionParameter>) </ParameterClause><ReturnClause>-> <TupleType>(<TupleTypeElement><SimpleTypeIdentifier>Float</SimpleTypeIdentifier>, </TupleTypeElement><TupleTypeElement><SimpleTypeIdentifier>Float</SimpleTypeIdentifier></TupleTypeElement>) </TupleType></ReturnClause></FunctionSignature><CodeBlock>{<ReturnStmt>
   return <TupleExpr>(<TupleExprElement><IdentifierExpr>v</IdentifierExpr>, </TupleExprElement><TupleExprElement><PrefixOperatorExpr>-<IdentifierExpr>v</IdentifierExpr></PrefixOperatorExpr></TupleExprElement>)</TupleExpr></ReturnStmt>
+}</CodeBlock></FunctionDecl><FunctionDecl><Attribute>
+
+@transpose(<DerivativeRegistrationAttributeArguments>of: <QualifiedDeclName><SimpleTypeIdentifier>Float</SimpleTypeIdentifier>.-</QualifiedDeclName>, <DifferentiationParamsClause>wrt: <DifferentiationParams>(<DifferentiationParam>0, </DifferentiationParam><DifferentiationParam>1</DifferentiationParam>)</DifferentiationParams></DifferentiationParamsClause></DerivativeRegistrationAttributeArguments>)</Attribute>
+func subtractTranspose<FunctionSignature><ParameterClause>(<FunctionParameter>_ v: <SimpleTypeIdentifier>Float</SimpleTypeIdentifier></FunctionParameter>) </ParameterClause><ReturnClause>-> <TupleType>(<TupleTypeElement><SimpleTypeIdentifier>Float</SimpleTypeIdentifier>, </TupleTypeElement><TupleTypeElement><SimpleTypeIdentifier>Float</SimpleTypeIdentifier></TupleTypeElement>) </TupleType></ReturnClause></FunctionSignature><CodeBlock>{<ReturnStmt>
+  return <TupleExpr>(<TupleExprElement><IdentifierExpr>v</IdentifierExpr>, </TupleExprElement><TupleExprElement><PrefixOperatorExpr>-<IdentifierExpr>v</IdentifierExpr></PrefixOperatorExpr></TupleExprElement>)</TupleExpr></ReturnStmt>
+}</CodeBlock></FunctionDecl><FunctionDecl><Attribute>
+
+@transpose(<DerivativeRegistrationAttributeArguments>of: <QualifiedDeclName><MemberTypeIdentifier><MemberTypeIdentifier><SimpleTypeIdentifier>A</SimpleTypeIdentifier>.B</MemberTypeIdentifier>.C</MemberTypeIdentifier>.foo<DeclNameArguments>(<DeclNameArgument>label:</DeclNameArgument><DeclNameArgument>_:</DeclNameArgument>)</DeclNameArguments></QualifiedDeclName>, <DifferentiationParamsClause>wrt: <DifferentiationParams>(<DifferentiationParam>0</DifferentiationParam>)</DifferentiationParams></DifferentiationParamsClause></DerivativeRegistrationAttributeArguments>)</Attribute>
+func qualifiedTranspose<FunctionSignature><ParameterClause>(<FunctionParameter>_ v: <SimpleTypeIdentifier>Float</SimpleTypeIdentifier></FunctionParameter>) </ParameterClause><ReturnClause>-> <TupleType>(<TupleTypeElement><SimpleTypeIdentifier>Float</SimpleTypeIdentifier>, </TupleTypeElement><TupleTypeElement><SimpleTypeIdentifier>Float</SimpleTypeIdentifier></TupleTypeElement>) </TupleType></ReturnClause></FunctionSignature><CodeBlock>{<ReturnStmt>
+  return <TupleExpr>(<TupleExprElement><IdentifierExpr>v</IdentifierExpr>, </TupleExprElement><TupleExprElement><PrefixOperatorExpr>-<IdentifierExpr>v</IdentifierExpr></PrefixOperatorExpr></TupleExprElement>)</TupleExpr></ReturnStmt>
 }</CodeBlock></FunctionDecl>

test/AutoDiff/Syntax/round_trip_parse_gen.swift

@@ -50,6 +50,12 @@ func bazDerivative(_ x: Float, y: Float)
   return (x, { v in v })
 }
 
+@derivative(of: A.B.C.foo(label:_:), wrt: (x))
+func qualifiedDerivative(_ x: Float, y: Float)
+    -> (value: Float, pullback: (Float) -> Float) {
+  return (x, { v in v })
+}
+
 @transpose(of: +)
 func addTranspose(_ v: Float) -> (Float, Float) {
   return (v, v)
@@ -59,3 +65,13 @@ func addTranspose(_ v: Float) -> (Float, Float) {
 func subtractTranspose(_ v: Float) -> (Float, Float) {
   return (v, -v)
 }
+
+@transpose(of: Float.-, wrt: (0, 1))
+func subtractTranspose(_ v: Float) -> (Float, Float) {
+  return (v, -v)
+}
+
+@transpose(of: A.B.C.foo(label:_:), wrt: (0))
+func qualifiedTranspose(_ v: Float) -> (Float, Float) {
+  return (v, -v)
+}