[Macros] Parse macro declarations.

Author: DougGregor

include/swift/AST/DiagnosticsParse.def

@@ -1999,8 +1999,22 @@ ERROR(foreign_diagnostic,none,
       "%0", (StringRef))
 
 //------------------------------------------------------------------------------
-// MARK: macro expansion
+// MARK: macros
 //------------------------------------------------------------------------------
+ERROR(expected_macro_value_type,PointsToFirstBadToken,
+      "expected macro value type following ':'", ())
+ERROR(no_default_arg_macro,none,
+      "default arguments are not allowed in macros", ())
+ERROR(expected_lparen_macro,PointsToFirstBadToken,
+      "expected '(' for macro parameters or ':' for a value-like macro''", ())
+ERROR(macro_decl_expected_arrow,none,
+      "expected '->' after macro parameter list", ())
+ERROR(expected_type_macro_result,PointsToFirstBadToken,
+      "expected macro result type", ())
+ERROR(macro_decl_expected_equal,none,
+      "expected '=' to introduce external macro name", ())
+ERROR(macro_decl_expected_period,none,
+      "expected '.' between external macro module and type name", ())
 
 ERROR(macro_expansion_expr_expected_macro_identifier,none,
       "expected a macro identifier for a pound literal expression", ())

include/swift/Parse/Parser.h

@@ -1216,6 +1216,8 @@ class Parser {
   BodyAndFingerprint
   parseAbstractFunctionBodyDelayed(AbstractFunctionDecl *AFD);
 
+  ParserResult<MacroDecl> parseDeclMacro(DeclAttributes &Attributes);
+
   ParserStatus parsePrimaryAssociatedTypes(
       SmallVectorImpl<PrimaryAssociatedTypeName> &AssocTypeNames);
   ParserStatus parsePrimaryAssociatedTypeList(
@@ -1427,6 +1429,8 @@ class Parser {
     Curried,
     /// An enum element.
     EnumElement,
+    /// A macro.
+    Macro,
   };
 
   /// Whether we are at the start of a parameter name when parsing a parameter.

include/swift/Parse/Token.h

@@ -157,6 +157,7 @@ class Token {
 #define CONTEXTUAL_SIMPLE_DECL_ATTR(KW, ...) CONTEXTUAL_CASE(KW)
 #include "swift/AST/Attr.def"
 #undef CONTEXTUAL_CASE
+      .Case("macro", true)
       .Default(false);
   }
 

lib/Parse/ParseDecl.cpp

@@ -4494,6 +4494,10 @@ bool Parser::isStartOfSwiftDecl(bool allowPoundIfAttributes) {
     return Tok.is(tok::identifier);
   }
 
+  // 'macro' name
+  if (Tok.isContextualKeyword("macro") && Tok2.is(tok::identifier))
+    return true;
+
   // If the next token is obviously not the start of a decl, bail early.
   if (!isKeywordPossibleDeclStart(Tok2))
     return false;
@@ -4824,6 +4828,12 @@ Parser::parseDecl(ParseDeclOptions Flags,
       break;
     }
 
+    if (Tok.isContextualKeyword("macro") && peekToken().is(tok::identifier)) {
+      Tok.setKind(tok::contextual_keyword);
+      DeclResult = parseDeclMacro(Attributes);
+      break;
+    }
+
     if (Flags.contains(PD_HasContainerType) &&
         IsAtStartOfLineOrPreviousHadSemi) {
 
@@ -8976,6 +8986,127 @@ Parser::parseDeclPrecedenceGroup(ParseDeclOptions flags,
   return makeParserResult(result);
 }
 
+ParserResult<MacroDecl> Parser::parseDeclMacro(DeclAttributes &Attributes) {
+  assert(Tok.isContextualKeyword("macro"));
+  SourceLoc macroLoc = consumeToken(); // 'macro'
+
+  Identifier macroName;
+  SourceLoc macroNameLoc;
+  ParserStatus status;
+
+  status |= parseIdentifierDeclName(
+      *this, macroName, macroNameLoc, "macro",
+      [&](const Token &next) {
+        return next.isAny(tok::colon, tok::l_paren) || startsWithLess(next);
+      });
+  if (status.isErrorOrHasCompletion())
+    return status;
+
+  DebuggerContextChange dcc (*this, macroName, DeclKind::Macro);
+
+  // Parse the generic-params, if present.
+  GenericParamList *genericParams = nullptr;
+  {
+    auto result = maybeParseGenericParams();
+    genericParams = result.getPtrOrNull();
+    if (result.hasCodeCompletion())
+      return makeParserCodeCompletionStatus();
+  }
+
+  // Parse the macro signature.
+  TypeRepr *resultType = nullptr;
+  ParameterList *parameterList = nullptr;
+  DeclName macroFullName;
+  if (consumeIf(tok::colon)) {
+    // Value-like macros.
+    auto type = parseType(diag::expected_macro_value_type);
+    status |= type;
+    if (status.isErrorOrHasCompletion())
+      return status;
+
+    resultType = type.getPtrOrNull();
+    macroFullName = macroName;
+  } else {
+    // Parameter list.
+    SmallVector<Identifier, 2> namePieces;
+    DefaultArgumentInfo defaultArgs;
+    auto parameterResult = parseSingleParameterClause(
+        ParameterContextKind::Macro, &namePieces, &defaultArgs);
+    status |= parameterResult;
+    parameterList = parameterResult.getPtrOrNull();
+
+    // ->
+    SourceLoc arrowLoc;
+    if (!consumeIf(tok::arrow, arrowLoc)) {
+      diagnose(Tok, diag::macro_decl_expected_arrow);
+    }
+
+    // Result type.
+    auto parsedResultType =
+        parseDeclResultType(diag::expected_type_macro_result);
+    resultType = parsedResultType.getPtrOrNull();
+    status |= parsedResultType;
+    if (status.isErrorOrHasCompletion())
+      return status;
+
+    macroFullName = DeclName(Context, macroName, namePieces);
+  }
+
+  // Parse '=' ModuleName . MacroTypeName
+  if (!consumeIf(tok::equal)) {
+    diagnose(Tok, diag::macro_decl_expected_equal);
+  }
+
+  // ModuleName
+  Identifier externalMacroModule;
+  SourceLoc externalMacroModuleLoc;
+  status |= parseIdentifierDeclName(
+      *this, externalMacroModule, externalMacroModuleLoc,
+      "external macro module",
+      [&](const Token &next) {
+        return next.is(tok::period);
+      });
+  if (status.isErrorOrHasCompletion())
+    return status;
+
+  // '.'
+  if (!consumeIf(tok::period)) {
+    diagnose(Tok, diag::macro_decl_expected_period);
+  }
+
+  // MacroTypeName
+  Identifier externalMacroTypeName;
+  SourceLoc externalMacroTypeNameLoc;
+  status |= parseIdentifierDeclName(
+      *this, externalMacroTypeName, externalMacroTypeNameLoc,
+      "external macro type name",
+      [&](const Token &next) {
+        return true;
+      });
+  if (status.isErrorOrHasCompletion())
+    return status;
+
+  // Create the macro declaration.
+  auto *macro = new (Context) MacroDecl(
+      MacroDecl::Kind::Expression, MacroDecl::ImplementationKind::Builtin,
+      macroName, CurDeclContext->getParentModule(), { }, nullptr);
+
+  // FIXME: Egregious hack.
+  macro->setImplicit();
+
+  // Parse a 'where' clause if present.
+  if (Tok.is(tok::kw_where)) {
+    auto whereStatus = parseFreestandingGenericWhereClause(macro);
+    if (whereStatus.hasCodeCompletion() && !CodeCompletion) {
+      // Trigger delayed parsing, no need to continue.
+      return whereStatus;
+    }
+    status |= whereStatus;
+  }
+
+  return dcc.fixupParserResult(status, macro);
+}
+
 ParserResult<MacroExpansionDecl>
 Parser::parseDeclMacroExpansion(ParseDeclOptions flags,
                                 DeclAttributes &attributes) {

lib/Parse/ParsePattern.cpp

@@ -116,6 +116,9 @@ static ParserStatus parseDefaultArgument(
   case Parser::ParameterContextKind::Curried:
     diagID = diag::no_default_arg_curried;
     break;
+  case Parser::ParameterContextKind::Macro:
+    diagID = diag::no_default_arg_macro;
+    break;
   }
 
   assert((diagID.ID != DiagID()) == !defaultArgs &&
@@ -662,6 +665,7 @@ mapParsedParameters(Parser &parser,
     case Parser::ParameterContextKind::Curried:
     case Parser::ParameterContextKind::Initializer:
     case Parser::ParameterContextKind::Function:
+    case Parser::ParameterContextKind::Macro:
       isKeywordArgumentByDefault = true;
       break;
     }
@@ -741,6 +745,9 @@ Parser::parseSingleParameterClause(ParameterContextKind paramContext,
     case ParameterContextKind::Initializer:
       diagID = diag::expected_lparen_initializer;
       break;
+    case ParameterContextKind::Macro:
+      diagID = diag::expected_lparen_macro;
+      break;
     case ParameterContextKind::EnumElement:
     case ParameterContextKind::Closure:
     case ParameterContextKind::Curried: