[Macros] Always parse macro expansions, diagnose later

Always parse macro expansions, regardless of language mode, and
eliminate the fallback path for very, very, very old object literals
like `#Color`. Instead, check for the feature flag for macro
declaration and at macro expansion time, since this is a semantic
restriction.

While here, refactor things so the vast majority of the macro-handling
logic still applies even if the Swift Swift parser is disabled. Only
attempts to expand the macro will fail. This allows us to enable the
macro-diagnostics test everywhere.

Author: DougGregor

include/swift/AST/DiagnosticsCommon.def

@@ -219,6 +219,8 @@ ERROR(unknown_attribute,none,
 //------------------------------------------------------------------------------
 NOTE(in_macro_expansion,none,
      "in expansion of macro %0 here", (DeclName))
+ERROR(macro_experimental,none,
+      "macros are an experimental feature that is not enabled", ())
 
 //------------------------------------------------------------------------------
 // MARK: bridged diagnostics

include/swift/AST/DiagnosticsParse.def

@@ -1329,9 +1329,6 @@ ERROR(expected_rsquare_array_expr,PointsToFirstBadToken,
 // Object literal expressions
 ERROR(expected_arg_list_in_object_literal,PointsToFirstBadToken,
       "expected argument list in object literal", ())
-ERROR(legacy_object_literal,none,
-      "'%select{|[}0#%1(...)%select{|#]}0' has been renamed to '#%2(...)'",
-      (bool, StringRef, StringRef))
 
 // Unknown pound expression.
 ERROR(unknown_pound_expr,none,

include/swift/AST/DiagnosticsSema.def

@@ -6762,8 +6762,7 @@ ERROR(experimental_no_metadata_feature_can_only_be_used_when_enabled,
 ERROR(expected_macro_expansion_expr,PointsToFirstBadToken,
       "expected macro expansion to produce an expression", ())
 ERROR(macro_undefined,PointsToFirstBadToken,
-      "macro %0 is undefined; use `-load-plugin-library` to specify dynamic "
-      "libraries that contain this macro", (Identifier))
+      "no macro named %0", (Identifier))
 ERROR(external_macro_not_found,none,
       "external macro implementation type '%0.%1' could not be found for "
       "macro %2; the type must be public and provided via "
@@ -6798,6 +6797,8 @@ ERROR(macro_expansion_missing_pound,none,
       "expansion of macro %0 requires leading '#'", (DeclName))
 ERROR(macro_expansion_missing_arguments,none,
       "expansion of macro %0 requires arguments", (DeclName))
+ERROR(macro_unsupported,none,
+      "macros are not supported in this compiler", ())
 
 //------------------------------------------------------------------------------
 // MARK: Move Only Errors

include/swift/Parse/Parser.h

@@ -1748,7 +1748,6 @@ class Parser {
   ParserResult<Expr> parseExprMacroExpansion(bool isExprBasic);
   ParserResult<Expr> parseExprCollection();
   ParserResult<Expr> parseExprCollectionElement(Optional<bool> &isDictionary);
-  ParserResult<Expr> parseExprPoundUnknown(SourceLoc LSquareLoc);
   ParserResult<Expr>
   parseExprPoundCodeCompletion(Optional<StmtKind> ParentKind);
 

lib/Parse/ParseDecl.cpp

@@ -4844,11 +4844,11 @@ Parser::parseDecl(ParseDeclOptions Flags,
       consumeToken(tok::code_complete);
       DeclResult = makeParserCodeCompletionResult<Decl>();
       break;
-    } else if (Context.LangOpts.hasFeature(Feature::Macros)) {
-      DeclResult = parseDeclMacroExpansion(Flags, Attributes);
-      break;
     }
-    LLVM_FALLTHROUGH;
+
+    // Parse as a macro expansion.
+    DeclResult = parseDeclMacroExpansion(Flags, Attributes);
+    break;
 
   case tok::pound_if:
   case tok::pound_sourceLocation:

lib/Parse/ParseExpr.cpp

@@ -1774,14 +1774,8 @@ ParserResult<Expr> Parser::parseExprPrimary(Diag<> ID, bool isExprBasic) {
         Tok.getLoc().getAdvancedLoc(1) == peekToken().getLoc()) {
       return parseExprPoundCodeCompletion(/*ParentKind*/None);
     }
-    if (Context.LangOpts.hasFeature(Feature::Macros)) {
-      return parseExprMacroExpansion(isExprBasic);
-    }
-    if (peekToken().is(tok::identifier) && !peekToken().isEscapedIdentifier() &&
-        Tok.getLoc().getAdvancedLoc(1) == peekToken().getLoc()) {
-      return parseExprPoundUnknown(SourceLoc());
-    }
-    goto UnknownCharacter;
+
+    return parseExprMacroExpansion(isExprBasic);
 
   // Eat an invalid token in an expression context.  Error tokens are diagnosed
   // by the lexer, so there is no reason to emit another diagnostic.
@@ -3245,82 +3239,6 @@ Parser::parseExprObjectLiteral(ObjectLiteralExpr::LiteralKind LitKind,
                                                     /*implicit*/ false));
 }
 
-/// Parse and diagnose unknown pound expression
-///
-/// If it look like a legacy (Swift 2) object literal expression, suggest fix-it
-/// to use new object literal syntax.
-///
-/// expr-unknown-pound:
-///   '#' identifier expr-paren?
-///   '[' '#' identifier expr-paren? '#' ']' ; Legacy object literal
-ParserResult<Expr> Parser::parseExprPoundUnknown(SourceLoc LSquareLoc) {
-  SourceLoc PoundLoc = consumeToken(tok::pound);
-
-  assert(Tok.is(tok::identifier) && !Tok.isEscapedIdentifier() &&
-         PoundLoc.getAdvancedLoc(1) == Tok.getLoc());
-
-  Identifier Name;
-  SourceLoc NameLoc = consumeIdentifier(Name, /*diagnoseDollarPrefix=*/false);
-
-  // Parse arguments if exist.
-  ArgumentList *ArgList = nullptr;
-  if (Tok.isFollowingLParen()) {
-    // Parse arguments.
-    auto result = parseArgumentList(tok::l_paren, tok::r_paren,
-                                    /*isExprBasic*/ true);
-    if (result.hasCodeCompletion())
-      return makeParserCodeCompletionResult<Expr>();
-    if (result.isParseErrorOrHasCompletion())
-      return makeParserError();
-    ArgList = result.get();
-  }
-
-  std::pair<StringRef, StringRef> NewNameArgPair =
-      llvm::StringSwitch<std::pair<StringRef, StringRef>>(Name.str())
-          .Case("Color", {"colorLiteral", "red"})
-          .Case("Image", {"imageLiteral", "resourceName"})
-          .Case("FileReference", {"fileLiteral", "resourceName"})
-          .Default({});
-
-  // If it's not legacy object literal, we don't know how to handle this.
-  if (NewNameArgPair.first.empty()) {
-    diagnose(PoundLoc, diag::unknown_pound_expr, Name.str());
-    return makeParserError();
-  }
-
-  // Diagnose legacy object literal.
-
-  // Didn't have arguments.
-  if (!ArgList || ArgList->getLParenLoc().isInvalid()) {
-    diagnose(Tok.getLoc(), diag::expected_arg_list_in_object_literal);
-    return makeParserError();
-  }
-
-  // If it's started with '[', try to parse closing '#]'.
-  SourceLoc RPoundLoc, RSquareLoc;
-  if (LSquareLoc.isValid() && consumeIf(tok::pound, RPoundLoc))
-    consumeIf(tok::r_square, RSquareLoc);
-
-  auto diag = diagnose(LSquareLoc.isValid() ? LSquareLoc : PoundLoc,
-                       diag::legacy_object_literal, LSquareLoc.isValid(),
-                       Name.str(), NewNameArgPair.first);
-
-  // Remove '[' if exist.
-  if (LSquareLoc.isValid())
-    diag.fixItRemove(LSquareLoc);
-  // Replace the literal name.
-  diag.fixItReplace(NameLoc, NewNameArgPair.first);
-  // Replace the first argument.
-  if (!ArgList->empty() && ArgList->front().getLabelLoc().isValid())
-    diag.fixItReplace(ArgList->front().getLabelLoc(), NewNameArgPair.second);
-  // Remove '#]' if exist.
-  if (RPoundLoc.isValid())
-    diag.fixItRemove(
-        {RPoundLoc, RSquareLoc.isValid() ? RSquareLoc : RPoundLoc});
-
-  return makeParserError();
-}
-
 /// Handle code completion after pound in expression position.
 ///
 /// In case it's in a stmt condition position, specify \p ParentKind to
@@ -3460,14 +3378,6 @@ ParserResult<Expr> Parser::parseExprCollection() {
                DictionaryExpr::create(Context, LSquareLoc, {}, {}, RSquareLoc));
   }
 
-  // [#identifier is likely to be a legacy object literal.
-  if (Tok.is(tok::pound) && peekToken().is(tok::identifier) &&
-      !peekToken().isEscapedIdentifier() &&
-      LSquareLoc.getAdvancedLoc(1) == Tok.getLoc() &&
-      Tok.getLoc().getAdvancedLoc(1) == peekToken().getLoc()) {
-    return parseExprPoundUnknown(LSquareLoc);
-  }
-
   ParserStatus Status;
   Optional<bool> isDictionary;
   SmallVector<Expr *, 8> ElementExprs;

lib/Sema/CSApply.cpp

@@ -5387,27 +5387,21 @@ namespace {
     }
 
     Expr *visitMacroExpansionExpr(MacroExpansionExpr *E) {
-#if SWIFT_SWIFT_PARSER
-      auto &ctx = cs.getASTContext();
-      if (ctx.LangOpts.hasFeature(Feature::Macros)) {
-        auto expandedType = solution.simplifyType(solution.getType(E));
-        cs.setType(E, expandedType);
+      auto expandedType = solution.simplifyType(solution.getType(E));
+      cs.setType(E, expandedType);
 
-        auto locator = cs.getConstraintLocator(E);
-        auto overload = solution.getOverloadChoice(locator);
+      auto locator = cs.getConstraintLocator(E);
+      auto overload = solution.getOverloadChoice(locator);
 
-        auto macro = cast<MacroDecl>(overload.choice.getDecl());
-        ConcreteDeclRef macroRef = resolveConcreteDeclRef(macro, locator);
-        E->setMacroRef(macroRef);
+      auto macro = cast<MacroDecl>(overload.choice.getDecl());
+      ConcreteDeclRef macroRef = resolveConcreteDeclRef(macro, locator);
+      E->setMacroRef(macroRef);
 
-        if (auto newExpr = expandMacroExpr(dc, E, macroRef, expandedType)) {
-          E->setRewritten(newExpr);
-          cs.cacheExprTypes(E);
-          return E;
-        }
-        // Fall through to use old implementation.
+      if (auto newExpr = expandMacroExpr(dc, E, macroRef, expandedType)) {
+        E->setRewritten(newExpr);
+        cs.cacheExprTypes(E);
       }
-#endif
+
       return E;
     }
 

lib/Sema/CSGen.cpp

@@ -3779,67 +3779,62 @@ namespace {
     }
 
     Type visitMacroExpansionExpr(MacroExpansionExpr *expr) {
-#if SWIFT_SWIFT_PARSER
       auto &ctx = CS.getASTContext();
-      if (ctx.LangOpts.hasFeature(Feature::Macros)) {
-        auto locator = CS.getConstraintLocator(expr);
-
-        // For calls, set up the argument list.
-        bool isCall = expr->getArgs() != nullptr;
-        if (isCall) {
-          CS.associateArgumentList(locator, expr->getArgs());
-        }
+      auto locator = CS.getConstraintLocator(expr);
 
-        // Look up the macros with this name.
-        auto macroIdent = expr->getMacroName().getBaseIdentifier();
-        FunctionRefKind functionRefKind = isCall ? FunctionRefKind::SingleApply
-                                                 : FunctionRefKind::Unapplied;
-        auto macros = lookupMacros(
-            macroIdent, expr->getMacroNameLoc().getBaseNameLoc(),
-            functionRefKind);
-        if (macros.empty()) {
-          ctx.Diags.diagnose(expr->getMacroNameLoc(), diag::macro_undefined,
-                             macroIdent)
-              .highlight(expr->getMacroNameLoc().getSourceRange());
-          return Type();
-        }
+      // For calls, set up the argument list.
+      bool isCall = expr->getArgs() != nullptr;
+      if (isCall) {
+        CS.associateArgumentList(locator, expr->getArgs());
+      }
+
+      // Look up the macros with this name.
+      auto macroIdent = expr->getMacroName().getBaseIdentifier();
+      FunctionRefKind functionRefKind = isCall ? FunctionRefKind::SingleApply
+                                               : FunctionRefKind::Unapplied;
+      auto macros = lookupMacros(
+          macroIdent, expr->getMacroNameLoc().getBaseNameLoc(),
+          functionRefKind);
+      if (macros.empty()) {
+        ctx.Diags.diagnose(expr->getMacroNameLoc(), diag::macro_undefined,
+                           macroIdent)
+            .highlight(expr->getMacroNameLoc().getSourceRange());
+        return Type();
+      }
 
-        // Introduce an overload set for the macro reference.
-        auto macroRefType = Type(CS.createTypeVariable(locator, 0));
-        CS.addOverloadSet(macroRefType, macros, CurDC, locator);
+      // Introduce an overload set for the macro reference.
+      auto macroRefType = Type(CS.createTypeVariable(locator, 0));
+      CS.addOverloadSet(macroRefType, macros, CurDC, locator);
 
-        // Add explicit generic arguments, if there were any.
-        if (expr->getGenericArgsRange().isValid()) {
-          if (addSpecializationConstraint(
-                CS.getConstraintLocator(expr), macroRefType,
-                expr->getGenericArgs()))
-            return Type();
-        }
+      // Add explicit generic arguments, if there were any.
+      if (expr->getGenericArgsRange().isValid()) {
+        if (addSpecializationConstraint(
+              CS.getConstraintLocator(expr), macroRefType,
+              expr->getGenericArgs()))
+          return Type();
+      }
 
-        // For non-calls, the type variable is the result.
-        if (!isCall)
-          return macroRefType;
+      // For non-calls, the type variable is the result.
+      if (!isCall)
+        return macroRefType;
 
-        // For calls, form the applicable-function constraint. The result type
-        // is the result of that call.
-        SmallVector<AnyFunctionType::Param, 8> params;
-        getMatchingParams(expr->getArgs(), params);
+      // For calls, form the applicable-function constraint. The result type
+      // is the result of that call.
+      SmallVector<AnyFunctionType::Param, 8> params;
+      getMatchingParams(expr->getArgs(), params);
 
-        Type resultType = CS.createTypeVariable(
-            CS.getConstraintLocator(expr, ConstraintLocator::FunctionResult),
-            TVO_CanBindToNoEscape);
+      Type resultType = CS.createTypeVariable(
+          CS.getConstraintLocator(expr, ConstraintLocator::FunctionResult),
+          TVO_CanBindToNoEscape);
 
-        CS.addConstraint(
-            ConstraintKind::ApplicableFunction,
-            FunctionType::get(params, resultType),
-            macroRefType,
-            CS.getConstraintLocator(
-              expr, ConstraintLocator::ApplyFunction));
+      CS.addConstraint(
+          ConstraintKind::ApplicableFunction,
+          FunctionType::get(params, resultType),
+          macroRefType,
+          CS.getConstraintLocator(
+            expr, ConstraintLocator::ApplyFunction));
 
-        return resultType;
-      }
-#endif
-      return Type();
+      return resultType;
     }
 
     static bool isTriggerFallbackDiagnosticBuiltin(UnresolvedDotExpr *UDE,

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -1998,6 +1998,8 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     TypeChecker::checkDeclAttributes(MD);
     checkAccessControl(MD);
 
+    if (!Ctx.LangOpts.hasFeature(Feature::Macros))
+      MD->diagnose(diag::macro_experimental);
     if (!MD->getDeclContext()->isModuleScopeContext())
       MD->diagnose(diag::macro_in_nested, MD->getName());
     if (!MD->getMacroContexts())

lib/Sema/TypeCheckMacros.cpp

@@ -121,7 +121,6 @@ MacroDefinition MacroDefinitionRequest::evaluate(
       ctx, macro->externalModuleName, macro->externalMacroTypeName);
 }
 
-#if SWIFT_SWIFT_PARSER
 Expr *swift::expandMacroExpr(
     DeclContext *dc, Expr *expr, ConcreteDeclRef macroRef, Type expandedType
 ) {
@@ -157,6 +156,13 @@ Expr *swift::expandMacroExpr(
   }
 
   case MacroDefinition::ImplementationKind::InProcess: {
+    // Make sure macros are enabled before we expand.
+    if (!ctx.LangOpts.hasFeature(Feature::Macros)) {
+      ctx.Diags.diagnose(expr->getLoc(), diag::macro_experimental);
+      return nullptr;
+    }
+
+#if SWIFT_SWIFT_PARSER
     PrettyStackTraceExpr debugStack(ctx, "expanding macro", expr);
 
     // Builtin macros are handled via ASTGen.
@@ -176,6 +182,10 @@ Expr *swift::expandMacroExpr(
     evaluatedSource = NullTerminatedStringRef(evaluatedSourceAddress,
                                               (size_t)evaluatedSourceLength);
     break;
+#else
+    ctx.Diags.diagnose(expr->getLoc(), diag::macro_unsupported);
+    return nullptr;
+#endif
   }
   }
 
@@ -266,5 +276,3 @@ Expr *swift::expandMacroExpr(
          "Type checking changed the result type?");
   return expandedExpr;
 }
-
-#endif // SWIFT_SWIFT_PARSER