[Parse] Separate compilation condition validation and evaluation

include/swift/AST/DiagnosticsParse.def

@@ -1408,6 +1408,12 @@ ERROR(unsupported_conditional_compilation_expression_type,none,
 WARNING(swift3_unsupported_conditional_compilation_expression_type,none,
         "ignoring invalid conditional compilation expression, "
         "which will be rejected in future version of Swift", ())
+WARNING(swift3_conditional_compilation_expression_compound,none,
+        "ignoring parentheses in compound name, "
+        "which will be rejected in future version of Swift", ())
+WARNING(swift3_conditional_compilation_expression_precedence,none,
+        "future version of Swift have different rule for evaluating condition; "
+        "add parentheses to make the condition compatible with Swift4", ())
 ERROR(unsupported_conditional_compilation_integer,none,
       "'%0' is not a valid conditional compilation expression, use '%1'",
       (StringRef, StringRef))

include/swift/Basic/Version.h

@@ -114,9 +114,9 @@ class Version {
   Version asMajorVersion() const;
 
   /// Parse a version in the form used by the _compiler_version \#if condition.
-  static Version parseCompilerVersionString(StringRef VersionString,
-                                            SourceLoc Loc,
-                                            DiagnosticEngine *Diags);
+  static Optional<Version> parseCompilerVersionString(StringRef VersionString,
+                                                      SourceLoc Loc,
+                                                      DiagnosticEngine *Diags);
 
   /// Parse a generic version string of the format [0-9]+(.[0-9]+)*
   ///

include/swift/Parse/Parser.h

@@ -1271,15 +1271,6 @@ class Parser {
   ParserResult<Stmt> parseStmtSwitch(LabeledStmtInfo LabelInfo);
   ParserResult<CaseStmt> parseStmtCase();
 
-  /// Classify the condition of an #if directive according to whether it can
-  /// be evaluated statically.  The first member of the pair indicates whether
-  /// parsing of the condition body should occur, the second contains the result
-  /// of evaluating the conditional expression.
-  static ConditionalCompilationExprState
-  classifyConditionalCompilationExpr(Expr *condition,
-                                     ASTContext &context,
-                                     DiagnosticEngine &diags);
-
   //===--------------------------------------------------------------------===//
   // Generics Parsing
 

include/swift/Parse/ParserResult.h

@@ -218,75 +218,6 @@ template <typename T> ParserResult<T>::ParserResult(ParserStatus Status) {
     setHasCodeCompletion();
 }
 
-enum class ConditionalCompilationExprKind {
-  Unknown,
-  Error,
-  OS,
-  Arch,
-  LanguageVersion,
-  CompilerVersion,
-  Binary,
-  Paren,
-  DeclRef,
-  Boolean,
-  Integer,
-  Import,
-};
-
-class ConditionalCompilationExprState {
-
-  uint8_t ConditionActive : 1;
-  uint8_t Kind : 7;
-public:
-  ConditionalCompilationExprState() : ConditionActive(false) {
-    setKind(ConditionalCompilationExprKind::Unknown);
-  }
-
-  ConditionalCompilationExprState(bool ConditionActive,
-                                  ConditionalCompilationExprKind Kind)
-  : ConditionActive(ConditionActive) {
-    setKind(Kind);
-  }
-
-  bool isConditionActive() const {
-    return ConditionActive;
-  }
-
-  void setConditionActive(bool A) {
-    ConditionActive = A;
-  }
-
-  ConditionalCompilationExprKind getKind() const {
-    return static_cast<ConditionalCompilationExprKind>(Kind);
-  }
-
-  void setKind(ConditionalCompilationExprKind K) {
-    Kind = static_cast<uint8_t>(K);
-    assert(getKind() == K);
-  }
-
-  bool shouldParse() const {
-    if (getKind() == ConditionalCompilationExprKind::Error)
-      return true;
-    return ConditionActive ||
-    (getKind() != ConditionalCompilationExprKind::CompilerVersion &&
-     getKind() != ConditionalCompilationExprKind::LanguageVersion);
-  }
-
-  static ConditionalCompilationExprState error() {
-    return {false, ConditionalCompilationExprKind::Error};
-  }
-};
-
-ConditionalCompilationExprState
-operator&&(const ConditionalCompilationExprState lhs,
-           const ConditionalCompilationExprState rhs);
-ConditionalCompilationExprState
-operator||(const ConditionalCompilationExprState lhs,
-           const ConditionalCompilationExprState rhs);
-ConditionalCompilationExprState
-operator!(const ConditionalCompilationExprState Result);
-
 } // namespace swift
 
 #endif // LLVM_SWIFT_PARSER_PARSER_RESULT_H

lib/AST/ASTDumper.cpp

@@ -1042,12 +1042,16 @@ namespace {
       for (auto &Clause : ICD->getClauses()) {
         if (Clause.Cond) {
           PrintWithColorRAII(OS, ParenthesisColor) << '(';
-          OS << "#if:\n";
+          OS << "#if:";
+          if (Clause.isActive) OS << " active";
+          OS << "\n";
           printRec(Clause.Cond);
         } else {
           OS << '\n';
           PrintWithColorRAII(OS, ParenthesisColor) << '(';
-          OS << "#else:\n";
+          OS << "#else:";
+          if (Clause.isActive) OS << " active";
+          OS << "\n";
         }
 
         for (auto D : Clause.Elements) {
@@ -1416,10 +1420,15 @@ class PrintStmt : public StmtVisitor<PrintStmt> {
       OS.indent(Indent);
       if (Clause.Cond) {
         PrintWithColorRAII(OS, ParenthesisColor) << '(';
-        PrintWithColorRAII(OS, StmtColor) << "#if:\n";
+        PrintWithColorRAII(OS, StmtColor) << "#if:";
+        if (Clause.isActive)
+          PrintWithColorRAII(OS, DeclModifierColor) << " active";
+        OS << '\n';
         printRec(Clause.Cond);
       } else {
         PrintWithColorRAII(OS, StmtColor) << "#else";
+        if (Clause.isActive)
+          PrintWithColorRAII(OS, DeclModifierColor) << " active";
       }
 
       OS << '\n';

lib/Basic/Version.cpp

@@ -75,10 +75,10 @@ static void printFullRevisionString(raw_ostream &out) {
 #endif
 }
 
-void splitVersionComponents(
+static void splitVersionComponents(
   SmallVectorImpl<std::pair<StringRef, SourceRange>> &SplitComponents,
                             StringRef &VersionString, SourceLoc Loc,
-                            DiagnosticEngine *Diags, bool skipQuote = false) {
+                            bool skipQuote = false) {
   SourceLoc Start = (Loc.isValid() && skipQuote) ? Loc.getAdvancedLoc(1) : Loc;
   SourceLoc End = Start;
 
@@ -99,31 +99,31 @@ void splitVersionComponents(
   }
 }
 
-Version Version::parseCompilerVersionString(
+Optional<Version> Version::parseCompilerVersionString(
   StringRef VersionString, SourceLoc Loc, DiagnosticEngine *Diags) {
 
   Version CV;
   SmallString<16> digits;
   llvm::raw_svector_ostream OS(digits);
   SmallVector<std::pair<StringRef, SourceRange>, 5> SplitComponents;
 
+  splitVersionComponents(SplitComponents, VersionString, Loc,
+                         /*skipQuote=*/true);
+
+  uint64_t ComponentNumber;
+  bool isValidVersion = true;
+
   auto checkVersionComponent = [&](unsigned Component, SourceRange Range) {
     unsigned limit = CV.Components.size() == 0 ? 9223371 : 999;
 
     if (Component > limit) {
       if (Diags)
         Diags->diagnose(Range.Start,
                         diag::compiler_version_component_out_of_range, limit);
-      else
-        llvm_unreachable("Compiler version component out of range");
+      isValidVersion = false;
     }
   };
 
-  splitVersionComponents(SplitComponents, VersionString, Loc, Diags,
-                         /*skipQuote=*/true);
-
-  uint64_t ComponentNumber;
-
   for (size_t i = 0; i < SplitComponents.size(); ++i) {
     StringRef SplitComponent;
     SourceRange Range;
@@ -133,20 +133,16 @@ Version Version::parseCompilerVersionString(
     if (SplitComponent.empty()) {
       if (Diags)
         Diags->diagnose(Range.Start, diag::empty_version_component);
-      else
-        llvm_unreachable("Found empty compiler version component");
+      isValidVersion = false;
       continue;
     }
 
     // The second version component isn't used for comparison.
     if (i == 1) {
       if (!SplitComponent.equals("*")) {
-        if (Diags) {
+        if (Diags)
           Diags->diagnose(Range.Start, diag::unused_compiler_version_component)
           .fixItReplaceChars(Range.Start, Range.End, "*");
-        } else {
-          llvm_unreachable("Expected * for second compiler version component");
-        }
       }
 
       CV.Components.push_back(0);
@@ -158,23 +154,20 @@ Version Version::parseCompilerVersionString(
       checkVersionComponent(ComponentNumber, Range);
       CV.Components.push_back(ComponentNumber);
       continue;
-    } else if (Diags) {
-      Diags->diagnose(Range.Start,
-                      diag::version_component_not_number);
     } else {
-      llvm_unreachable("Invalid character in _compiler_version condition");
+      if (Diags)
+        Diags->diagnose(Range.Start, diag::version_component_not_number);
+      isValidVersion = false;
     }
   }
 
   if (CV.Components.size() > 5) {
-    if (Diags) {
+    if (Diags)
       Diags->diagnose(Loc, diag::compiler_version_too_many_components);
-    } else {
-      llvm_unreachable("Compiler version must not have more than 5 components");
-    }
+    isValidVersion = false;
   }
 
-  return CV;
+  return isValidVersion ? Optional<Version>(CV) : None;
 }
 
 Optional<Version> Version::parseVersionString(StringRef VersionString,