SE-0020: Swift Language Version Build Configuration

Introduce a new "swift" build configuration that guards declarations
and statements with a language version - if the current language version
of the compiler is at least that version, the block will parse as normal.
For inactive blocks, the code will not be parsed an no diagnostics will
be emitted there.

Example:

    #if swift(>=2.2)
      print("Active")
    #else
      this code will not parse or emit diagnostics
    #endif

https://github.com/apple/swift-evolution/blob/master/proposals/0020-if-swift-version.md
rdar://problem/19823607

Author: bitjammer

include/swift/AST/DiagnosticsParse.def

@@ -1197,33 +1197,38 @@ ERROR(unsupported_build_config_binary_expression,none,
 ERROR(unsupported_build_config_unary_expression,none,
       "expected unary '!' expression", ())
 ERROR(unsupported_target_config_expression,none,
-      "unexpected target configuration expression (expected 'os' or 'arch')",())
+      "unexpected target configuration expression (expected 'os', 'arch', or 'swift')",
+      ())
+ERROR(target_config_expected_one_argument,none,
+      "expected only one argument to target configuration expression",
+      ())
 ERROR(unsupported_target_config_runtime_argument,none,
       "unexpected argument for the '_runtime' target configuration, "
       "expected '_Native' or '_ObjC'", ())
 ERROR(unsupported_target_config_argument,none,
-      "unexpected target configuration expression argument: expected %0",
+      "unexpected target configuration argument: expected %0",
       (StringRef))
+ERROR(unexpected_version_comparison_operator,none,
+      "expected '>=' prefix operator on a version requirement",
+      ())
 ERROR(unsupported_config_conditional_expression_type,none,
       "unexpected configuration expression type", ())
 ERROR(unsupported_config_integer,none,
       "'%0' is not a valid configuration option, use '%1'",
       (StringRef, StringRef))
-ERROR(compiler_version_component_not_number,none,
-      "compiler version component is not a number", ())
+ERROR(version_component_not_number,none,
+      "version component contains non-numeric characters", ())
 ERROR(compiler_version_too_many_components,none,
 			"compiler version must not have more than five components", ())
 WARNING(unused_compiler_version_component,none,
 			"the second version component is not used for comparison", ())
-ERROR(empty_compiler_version_component,none,
-			"found empty compiler version component", ())
+ERROR(empty_version_component,none,
+			"found empty version component", ())
 ERROR(compiler_version_component_out_of_range,none,
       "compiler version component out of range: must be in [0, %0]",
       (unsigned))
-ERROR(empty_compiler_version_string,none,
-      "compiler version requirement is empty", ())
-ERROR(cannot_combine_compiler_version,none,
-      "cannot combine _compiler_version with binary operators", ())
+ERROR(empty_version_string,none,
+      "version requirement is empty", ())
 WARNING(unknown_build_config,none,
       "unknown %0 for build configuration '%1'",
       (StringRef, StringRef))

include/swift/Basic/Version.h

@@ -97,15 +97,19 @@ class Version {
   /// Parse a generic version string of the format [0-9]+(.[0-9]+)*
   ///
   /// Version components can be any unsigned 64-bit number.
-  static Version parseVersionString(llvm::StringRef VersionString,
-                                            SourceLoc Loc,
-                                            DiagnosticEngine *Diags);
+  static Optional<Version> parseVersionString(llvm::StringRef VersionString,
+                                              SourceLoc Loc,
+                                              DiagnosticEngine *Diags);
 
   /// Returns a version from the currently defined SWIFT_COMPILER_VERSION.
   ///
   /// If SWIFT_COMPILER_VERSION is undefined, this will return the empty
   /// compiler version.
   static Version getCurrentCompilerVersion();
+
+  /// Returns a version from the currently defined SWIFT_VERSION_MAJOR and
+  /// SWIFT_VERSION_MAJOR.
+  static Version getCurrentLanguageVersion();
 };
 
 bool operator>=(const Version &lhs, const Version &rhs);

include/swift/Parse/ParserResult.h

@@ -222,6 +222,7 @@ enum class ConfigExprKind {
   Error,
   OS,
   Arch,
+  LanguageVersion,
   CompilerVersion,
   Binary,
   Paren,
@@ -261,7 +262,9 @@ class ConfigParserState {
   bool shouldParse() const {
     if (Kind == ConfigExprKind::Error)
       return true;
-    return ConditionActive || (Kind != ConfigExprKind::CompilerVersion);
+    return ConditionActive ||
+      (Kind != ConfigExprKind::CompilerVersion &&
+       Kind != ConfigExprKind::LanguageVersion);
   }
 
   static ConfigParserState error() {

lib/Basic/Version.cpp

@@ -84,8 +84,8 @@ static void printFullRevisionString(raw_ostream &out) {
 void splitVersionComponents(
   SmallVectorImpl<std::pair<StringRef, SourceRange>> &SplitComponents,
                             StringRef &VersionString, SourceLoc Loc,
-                            DiagnosticEngine *Diags) {
-  SourceLoc Start = Loc.isValid() ? Loc.getAdvancedLoc(1) : Loc;
+                            DiagnosticEngine *Diags, bool skipQuote = false) {
+  SourceLoc Start = (Loc.isValid() && skipQuote) ? Loc.getAdvancedLoc(1) : Loc;
   SourceLoc End = Start;
 
   // Split the version string into tokens separated by the '.' character.
@@ -125,7 +125,8 @@ Version Version::parseCompilerVersionString(
     }
   };
 
-  splitVersionComponents(SplitComponents, VersionString, Loc, Diags);
+  splitVersionComponents(SplitComponents, VersionString, Loc, Diags,
+                         /*skipQuote=*/true);
 
   uint64_t ComponentNumber;
 
@@ -137,7 +138,7 @@ Version Version::parseCompilerVersionString(
     // Version components can't be empty.
     if (SplitComponent.empty()) {
       if (Diags)
-        Diags->diagnose(Range.Start, diag::empty_compiler_version_component);
+        Diags->diagnose(Range.Start, diag::empty_version_component);
       else
         llvm_unreachable("Found empty compiler version component");
       continue;
@@ -165,7 +166,7 @@ Version Version::parseCompilerVersionString(
       continue;
     } else if (Diags) {
       Diags->diagnose(Range.Start,
-                      diag::compiler_version_component_not_number);
+                      diag::version_component_not_number);
     } else {
       llvm_unreachable("Invalid character in _compiler_version build configuration");
     }
@@ -182,18 +183,25 @@ Version Version::parseCompilerVersionString(
   return CV;
 }
 
-Version Version::parseVersionString(StringRef VersionString,
-                                                    SourceLoc Loc,
-                                                    DiagnosticEngine *Diags) {
-  Version CV;
+Optional<Version> Version::parseVersionString(StringRef VersionString,
+                                              SourceLoc Loc,
+                                              DiagnosticEngine *Diags) {
+  Version TheVersion;
   SmallString<16> digits;
   llvm::raw_svector_ostream OS(digits);
   SmallVector<std::pair<StringRef, SourceRange>, 5> SplitComponents;
   // Skip over quote character in string literal.
 
+  if (VersionString.empty()) {
+    if (Diags)
+      Diags->diagnose(Loc, diag::empty_version_string);
+    return None;
+  }
+
   splitVersionComponents(SplitComponents, VersionString, Loc, Diags);
 
   uint64_t ComponentNumber;
+  bool isValidVersion = true;
 
   for (size_t i = 0; i < SplitComponents.size(); ++i) {
     StringRef SplitComponent;
@@ -203,37 +211,55 @@ Version Version::parseVersionString(StringRef VersionString,
     // Version components can't be empty.
     if (SplitComponent.empty()) {
       if (Diags)
-        Diags->diagnose(Range.Start, diag::empty_compiler_version_component);
-      else
-        llvm_unreachable("Found empty compiler version component");
+        Diags->diagnose(Range.Start, diag::empty_version_component);
+
+      isValidVersion = false;
       continue;
     }
 
     // All other version components must be numbers.
     if (!SplitComponent.getAsInteger(10, ComponentNumber)) {
-      CV.Components.push_back(ComponentNumber);
+      TheVersion.Components.push_back(ComponentNumber);
       continue;
-    } else if (Diags) {
-      Diags->diagnose(Range.Start,
-                      diag::compiler_version_component_not_number);
     } else {
-      llvm_unreachable("Invalid character in _compiler_version build configuration");
+      if (Diags)
+        Diags->diagnose(Range.Start,
+                        diag::version_component_not_number);
+      isValidVersion = false;
     }
   }
 
-  return CV;
+  return isValidVersion ? Optional<Version>(TheVersion) : None;
 }
 
 
 Version Version::getCurrentCompilerVersion() {
 #ifdef SWIFT_COMPILER_VERSION
-  return Version::parseVersionString(
+  auto currentVersion = Version::parseVersionString(
     SWIFT_COMPILER_VERSION, SourceLoc(), nullptr);
+  assert(currentVersion.hasValue() &&
+         "Embedded Swift language version couldn't be parsed: '"
+         SWIFT_COMPILER_VERSION
+         "'");
+  return currentVersion;
 #else
   return Version();
 #endif
 }
 
+Version Version::getCurrentLanguageVersion() {
+#ifndef SWIFT_VERSION_STRING
+#error Swift language version is not set!
+#endif
+  auto currentVersion = Version::parseVersionString(
+    SWIFT_VERSION_STRING, SourceLoc(), nullptr);
+  assert(currentVersion.hasValue() &&
+         "Embedded Swift language version couldn't be parsed: '"
+         SWIFT_VERSION_STRING
+         "'");
+  return currentVersion.getValue();
+}
+
 std::string Version::str() const {
   std::string VersionString;
   llvm::raw_string_ostream OS(VersionString);

lib/Parse/ParseStmt.cpp

@@ -1534,12 +1534,6 @@ ConfigParserState Parser::evaluateConfigConditionExpr(Expr *configExpr) {
         if (name.equals("||") || name.equals("&&")) {
           auto rhs = evaluateConfigConditionExpr(elements[iOperand]);
 
-          if (result.getKind() == ConfigExprKind::CompilerVersion
-              || rhs.getKind() == ConfigExprKind::CompilerVersion) {
-            diagnose(UDREOp->getLoc(), diag::cannot_combine_compiler_version);
-            return ConfigParserState::error();
-          }
-
           if (name.equals("||")) {
             result = result || rhs;
             if (result.isConditionActive())
@@ -1594,18 +1588,25 @@ ConfigParserState Parser::evaluateConfigConditionExpr(Expr *configExpr) {
   if (auto *CE = dyn_cast<CallExpr>(configExpr)) {
     // look up target config, and compare value
     auto fnNameExpr = dyn_cast<UnresolvedDeclRefExpr>(CE->getFn());
-    
+
     // Get the arg, which should be in a paren expression.
-    auto *PE = dyn_cast<ParenExpr>(CE->getArg());
-    if (!fnNameExpr || !PE) {
+    if (!fnNameExpr) {
       diagnose(CE->getLoc(), diag::unsupported_target_config_expression);
       return ConfigParserState::error();
     }
 
     auto fnName = fnNameExpr->getName().getBaseName().str();
 
+    auto *PE = dyn_cast<ParenExpr>(CE->getArg());
+    if (!PE) {
+      auto diag = diagnose(CE->getLoc(),
+                           diag::target_config_expected_one_argument);
+      return ConfigParserState::error();
+    }
+
     if (!fnName.equals("arch") && !fnName.equals("os") &&
         !fnName.equals("_runtime") &&
+        !fnName.equals("swift") &&
         !fnName.equals("_compiler_version")) {
       diagnose(CE->getLoc(), diag::unsupported_target_config_expression);
       return ConfigParserState::error();
@@ -1614,7 +1615,7 @@ ConfigParserState Parser::evaluateConfigConditionExpr(Expr *configExpr) {
     if (fnName.equals("_compiler_version")) {
       if (auto SLE = dyn_cast<StringLiteralExpr>(PE->getSubExpr())) {
         if (SLE->getValue().empty()) {
-          diagnose(CE->getLoc(), diag::empty_compiler_version_string);
+          diagnose(CE->getLoc(), diag::empty_version_string);
           return ConfigParserState::error();
         }
         auto versionRequirement =
@@ -1630,6 +1631,44 @@ ConfigParserState Parser::evaluateConfigConditionExpr(Expr *configExpr) {
                  "string literal");
         return ConfigParserState::error();
       }
+    } else if(fnName.equals("swift")) {
+      auto PUE = dyn_cast<PrefixUnaryExpr>(PE->getSubExpr());
+      if (!PUE) {
+        diagnose(PE->getSubExpr()->getLoc(),
+                 diag::unsupported_target_config_argument,
+                 "a unary comparison, such as '>=2.2'");
+        return ConfigParserState::error();
+      }
+
+      auto prefix = dyn_cast<UnresolvedDeclRefExpr>(PUE->getFn());
+      auto versionArg = PUE->getArg();
+      auto versionStartLoc = versionArg->getStartLoc();
+      auto endLoc = Lexer::getLocForEndOfToken(SourceMgr,
+                                               versionArg->getSourceRange().End);
+      CharSourceRange versionCharRange(SourceMgr, versionStartLoc,
+                                       endLoc);
+      auto versionString = SourceMgr.extractText(versionCharRange);
+
+      auto versionRequirement =
+        version::Version::parseVersionString(versionString,
+                                             versionStartLoc,
+                                             &Diags);
+
+      if (!versionRequirement.hasValue())
+        return ConfigParserState::error();
+
+      auto thisVersion = version::Version::getCurrentLanguageVersion();
+
+      if (!prefix->getName().getBaseName().str().equals(">=")) {
+        diagnose(PUE->getFn()->getLoc(),
+                 diag::unexpected_version_comparison_operator)
+          .fixItReplace(PUE->getFn()->getLoc(), ">=");
+        return ConfigParserState::error();
+      }
+
+      auto VersionNewEnough = thisVersion >= versionRequirement.getValue();
+      return ConfigParserState(VersionNewEnough,
+                               ConfigExprKind::LanguageVersion);
     } else {
       if (auto UDRE = dyn_cast<UnresolvedDeclRefExpr>(PE->getSubExpr())) {
         // The sub expression should be an UnresolvedDeclRefExpr (we won't

test/BuildConfigurations/basicParseErrors.swift

@@ -8,7 +8,7 @@ var x = 0
 var y = 0
 #endif
 
-#if swift(FOO) // expected-error {{unexpected target configuration expression (expected 'os' or 'arch')}}
+#if foo(BAR) // expected-error {{unexpected target configuration expression (expected 'os', 'arch', or 'swift')}}
 var z = 0
 #endif
 
@@ -28,7 +28,7 @@ func h() {}
 #endif /* bbb */
 
 #if foo.bar() 
-      .baz() // expected-error {{unexpected target configuration expression (expected 'os' or 'arch')}}
+      .baz() // expected-error {{unexpected target configuration expression (expected 'os', 'arch', or 'swift')}}
 
 #endif