Effectively revert swiftlang#5778

This reverts the contents of swiftlang#5778 and replaces it with a far simpler
implementation of condition resolution along with canImport.  When
combined with the optimizations in swiftlang#6279 we get the best of both worlds
with a performance win and a simpler implementation.

Author: CodaFi

include/swift/AST/AST.h

@@ -27,7 +27,6 @@
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/Pattern.h"
 #include "swift/AST/Stmt.h"
-#include "swift/AST/StmtTransformer.h"
 #include "swift/AST/Types.h"
 #include "swift/AST/TypeRepr.h"
 

include/swift/AST/Decl.h

@@ -1949,15 +1949,13 @@ class IfConfigDecl : public Decl {
   /// The array is ASTContext allocated.
   ArrayRef<IfConfigDeclClause> Clauses;
   SourceLoc EndLoc;
-
 public:
 
   IfConfigDecl(DeclContext *Parent, ArrayRef<IfConfigDeclClause> Clauses,
                SourceLoc EndLoc, bool HadMissingEnd)
     : Decl(DeclKind::IfConfig, Parent), Clauses(Clauses), EndLoc(EndLoc)
   {
     IfConfigDeclBits.HadMissingEnd = HadMissingEnd;
-    IfConfigDeclBits.HasBeenResolved = false;
   }
 
   ArrayRef<IfConfigDeclClause> getClauses() const { return Clauses; }
@@ -1974,9 +1972,6 @@ class IfConfigDecl : public Decl {
       return Clause->Members;
     return {};
   }
-
-  bool isResolved() const { return IfConfigDeclBits.HasBeenResolved; }
-  void setResolved() { IfConfigDeclBits.HasBeenResolved = true; }
 
   SourceLoc getEndLoc() const { return EndLoc; }
   SourceLoc getLoc() const { return Clauses[0].Loc; }

include/swift/AST/Stmt.h

@@ -685,7 +685,6 @@ class IfConfigStmt : public Stmt {
   ArrayRef<IfConfigStmtClause> Clauses;
   SourceLoc EndLoc;
   bool HadMissingEnd;
-  bool HasBeenResolved = false;
 
 public:
   IfConfigStmt(ArrayRef<IfConfigStmtClause> Clauses, SourceLoc EndLoc,
@@ -699,9 +698,6 @@ class IfConfigStmt : public Stmt {
   SourceLoc getEndLoc() const { return EndLoc; }
 
   bool hadMissingEnd() const { return HadMissingEnd; }
-
-  bool isResolved() { return HasBeenResolved; }
-  void setResolved() { HasBeenResolved = true; }
 
   const ArrayRef<IfConfigStmtClause> &getClauses() const { return Clauses; }
 

include/swift/AST/StmtTransformer.h

@@ -1231,13 +1231,13 @@ class Parser {
   ParserResult<CaseStmt> parseStmtCase();
 
   /// Classify the condition of an #if directive according to whether it can
-  /// be evaluated statically.  If evaluation is not possible, the result is
-  /// 'None'.
-  static Optional<bool>
+  /// 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,
-                                     bool fullCheck = false);
+                                     DiagnosticEngine &diags);
 
   //===--------------------------------------------------------------------===//
   // Generics Parsing

include/swift/Parse/Parser.h

@@ -217,6 +217,75 @@ 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

include/swift/Parse/ParserResult.h

@@ -130,15 +130,6 @@ namespace swift {
                               bool TokenizeInterpolatedString = true,
                               ArrayRef<Token> SplitTokens = ArrayRef<Token>());
 
-  /// Once parsing is complete, this walks the AST to resolve condition clauses
-  /// and other top-level validation.
-  void performConditionResolution(SourceFile &SF);
-
-  /// \brief Finish condition resolution for the bodies of function nodes that
-  /// were delayed during the first parsing pass.
-  void performDelayedConditionResolution(Decl *D, SourceFile &BSF,
-                                         SmallVectorImpl<Decl *> &ExtraTLCDs);
-
   /// Once parsing is complete, this walks the AST to resolve imports, record
   /// operators, and do other top-level validation.
   ///

include/swift/Subsystems.h

@@ -39,7 +39,6 @@ add_swift_library(swiftAST STATIC
   RawComment.cpp
   SILLayout.cpp
   Stmt.cpp
-  StmtTransformer.cpp
   SourceEntityWalker.cpp
   Substitution.cpp
   SubstitutionMap.cpp