Extract common code into StmtTransformer

Author: CodaFi

include/swift/AST/AST.h

@@ -27,6 +27,7 @@
 #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

@@ -1929,8 +1929,12 @@ struct IfConfigDeclClause {
 
   ArrayRef<Decl*> Members;
 
-  IfConfigDeclClause(SourceLoc Loc, Expr *Cond, ArrayRef<Decl*> Members)
-    : Loc(Loc), Cond(Cond), Members(Members) {
+  /// True if this is the active clause of the #if block.
+  bool isActive;
+
+  IfConfigDeclClause(SourceLoc Loc, Expr *Cond, ArrayRef<Decl*> Members,
+                     bool isActive)
+    : Loc(Loc), Cond(Cond), Members(Members), isActive(isActive) {
   }
 };
 
@@ -1955,7 +1959,20 @@ class IfConfigDecl : public Decl {
 
   ArrayRef<IfConfigDeclClause> getClauses() const { return Clauses; }
 
-  bool isResolved() { return HasBeenResolved; }
+  /// Return the active clause, or null if there is no active one.
+  const IfConfigDeclClause *getActiveClause() const {
+    for (auto &Clause : Clauses)
+      if (Clause.isActive) return &Clause;
+    return nullptr;
+  }
+
+  const ArrayRef<Decl*> getActiveMembers() const {
+    if (auto *Clause = getActiveClause())
+      return Clause->Members;
+    return {};
+  }
+
+  bool isResolved() const { return HasBeenResolved; }
   void setResolved() { HasBeenResolved = true; }
 
   SourceLoc getEndLoc() const { return EndLoc; }

include/swift/AST/DiagnosticsParse.def

@@ -1334,7 +1334,8 @@ ERROR(unsupported_conditional_compilation_binary_expression,none,
 ERROR(unsupported_conditional_compilation_unary_expression,none,
       "expected unary '!' expression", ())
 ERROR(unsupported_platform_condition_expression,none,
-      "unexpected platform condition (expected 'os', 'arch', or 'swift')",
+      "unexpected platform condition "
+      "(expected 'canImport', 'os', 'arch', or 'swift')",
       ())
 ERROR(platform_condition_expected_one_argument,none,
       "expected only one argument to platform condition",

include/swift/AST/Module.h

@@ -831,13 +831,13 @@ class SourceFile final : public FileUnit {
   std::vector<Decl*> Decls;
 
   /// The list of local type declarations in the source file.
-  SmallPtrSet<TypeDecl *, 4> LocalTypeDecls;
+  SmallPtrSet<TypeDecl *, 2> LocalTypeDecls;
 
   /// A set of special declaration attributes which require the
   /// Foundation module to be imported to work. If the foundation
   /// module is still not imported by the time type checking is
   /// complete, we diagnose.
-  std::map<DeclAttrKind, const DeclAttribute *> AttrsRequiringFoundation;
+  SmallPtrSet<const DeclAttribute *, 4> AttrsRequiringFoundation;
 
   /// A mapping from Objective-C selectors to the methods that have
   /// those selectors.

include/swift/AST/Stmt.h

@@ -668,30 +668,27 @@ struct IfConfigStmtClause {
   /// Elements inside the clause
   ArrayRef<ASTNode> Elements;
 
-  /// Whether or not name binding has resolved this statement.
-  bool HasBeenResolved = false;
+  /// True if this is the active clause of the #if block.
+  bool isActive;
 
   IfConfigStmtClause(SourceLoc Loc, Expr *Cond,
-                     ArrayRef<ASTNode> Elements)
-    : Loc(Loc), Cond(Cond), Elements(Elements) {
+                     ArrayRef<ASTNode> Elements, bool isActive)
+    : Loc(Loc), Cond(Cond), Elements(Elements), isActive(isActive) {
   }
-  
-public:
-  bool isResolved() const { return HasBeenResolved; }
-  void setResolved() { HasBeenResolved = true; }
 };
 
 /// IfConfigStmt - This class models the statement-side representation of
 /// #if/#else/#endif blocks.
 class IfConfigStmt : public Stmt {
   /// An array of clauses controlling each of the #if/#elseif/#else conditions.
   /// The array is ASTContext allocated.
-  MutableArrayRef<IfConfigStmtClause> Clauses;
+  ArrayRef<IfConfigStmtClause> Clauses;
   SourceLoc EndLoc;
   bool HadMissingEnd;
+  bool HasBeenResolved = false;
 
 public:
-  IfConfigStmt(MutableArrayRef<IfConfigStmtClause> Clauses, SourceLoc EndLoc,
+  IfConfigStmt(ArrayRef<IfConfigStmtClause> Clauses, SourceLoc EndLoc,
                bool HadMissingEnd)
   : Stmt(StmtKind::IfConfig, /*implicit=*/false),
     Clauses(Clauses), EndLoc(EndLoc), HadMissingEnd(HadMissingEnd) {}
@@ -703,7 +700,17 @@ class IfConfigStmt : public Stmt {
 
   bool hadMissingEnd() const { return HadMissingEnd; }
 
-  const MutableArrayRef<IfConfigStmtClause> &getClauses() const { return Clauses; }
+  bool isResolved() { return HasBeenResolved; }
+  void setResolved() { HasBeenResolved = true; }
+  
+  const ArrayRef<IfConfigStmtClause> &getClauses() const { return Clauses; }
+
+  ArrayRef<ASTNode> getActiveClauseElements() const {
+    for (auto &Clause : Clauses)
+      if (Clause.isActive)
+        return Clause.Elements;
+    return ArrayRef<ASTNode>();
+  }
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Stmt *S) {

include/swift/AST/StmtTransformer.h

@@ -0,0 +1,70 @@
+//===--- Stmt.h - Swift Language Statement ASTs -----------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the StmtTransformer class.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_STMTTRANSFORMER_H
+#define SWIFT_AST_STMTTRANSFORMER_H
+
+#include "swift/AST/ASTWalker.h"
+#include "swift/AST/Stmt.h"
+#include "swift/AST/Expr.h"
+
+#include <forward_list>
+
+namespace swift {
+class StmtTransformer {
+protected:
+  class ClosureFinder : public ASTWalker {
+    StmtTransformer &StmtTrans;
+  public:
+    ClosureFinder(StmtTransformer &CCR) : StmtTrans(CCR) { }
+    virtual std::pair<bool, Stmt *> walkToStmtPre(Stmt *S) {
+      if (isa<BraceStmt>(S)) {
+        // To respect nesting, don't walk into brace statements.
+        return { false, S };
+      } else {
+        return { true, S };
+      }
+    }
+    virtual std::pair<bool, Expr *> walkToExprPre(Expr *E) {
+      if (ClosureExpr *CE = dyn_cast<ClosureExpr>(E)) {
+        BraceStmt *B = CE->getBody();
+        if (B) {
+          BraceStmt *NB = StmtTrans.transformBraceStmt(B, false);
+          CE->setBody(NB, CE->hasSingleExpressionBody());
+        }
+      }
+      return { true, E };
+    }
+  };
+  ClosureFinder CF;
+  
+public:
+  StmtTransformer() : CF(*this) {}
+  virtual ~StmtTransformer() {}
+
+  const ASTWalker &getClosureFinder() const {
+    return CF;
+  }
+
+  virtual Stmt *transformStmt(Stmt *S);
+  virtual BraceStmt *transformBraceStmt(BraceStmt *BS, bool TopLevel);
+#define STMT(CLASS, PARENT) \
+  virtual CLASS##Stmt *transform##CLASS##Stmt(CLASS##Stmt *S);
+#include "swift/AST/StmtNodes.def"
+};
+};
+
+#endif /* SWIFT_AST_STMTTRANSFORMER_H */

include/swift/Parse/Parser.h

@@ -61,6 +61,9 @@ namespace swift {
     TopLevelLibrary,
     /// The body of the clause of an #if/#else/#endif block
     ConditionalBlock,
+    /// The body of the clause of an #if/#else/#endif block that was statically
+    /// determined to be inactive.
+    StaticallyInactiveConditionalBlock,
   };
 
 
@@ -615,9 +618,10 @@ class Parser {
                                    BraceItemListKind::Brace,
                                BraceItemListKind ConditionalBlockKind =
                                    BraceItemListKind::Brace);
-  ParserResult<BraceStmt> parseBraceItemList(Diag<> ID, bool inConfig = false);
+  ParserResult<BraceStmt> parseBraceItemList(Diag<> ID);
 
-  void parseIfConfigClauseElements(BraceItemListKind Kind,
+  void parseIfConfigClauseElements(bool isInactive,
+                                   BraceItemListKind Kind,
                                    SmallVectorImpl<ASTNode> &Elements);
 
   void parseTopLevelCodeDeclDelayed();
@@ -644,7 +648,6 @@ class Parser {
     PD_InStruct             = 1 << 9,
     PD_InEnum               = 1 << 10,
     PD_InLoop               = 1 << 11,
-    PD_InIfConfig           = 1 << 12,
   };
 
   /// Options that control the parsing of declarations.
@@ -693,7 +696,7 @@ class Parser {
   /// 'isLine = true' indicates parsing #line instead of #sourcelocation
   ParserStatus parseLineDirective(bool isLine = false);
 
-  void setLocalDiscriminator(ParseDeclOptions Flags, ValueDecl *D);
+  void setLocalDiscriminator(ValueDecl *D);
 
   /// Parse the optional attributes before a declaration.
   bool parseDeclAttributeList(DeclAttributes &Attributes,
@@ -1227,9 +1230,14 @@ class Parser {
   ParserResult<Stmt> parseStmtSwitch(LabeledStmtInfo LabelInfo);
   ParserResult<CaseStmt> parseStmtCase();
 
-  /// Classify the condition of an #if directive.
-  ConditionalCompilationExprKind
-  classifyConditionalCompilationExpr(Expr *condition);
+  /// 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>
+  classifyConditionalCompilationExpr(Expr *condition,
+                                     ASTContext &context,
+                                     DiagnosticEngine &diags,
+                                     bool fullCheck = false);
 
   //===--------------------------------------------------------------------===//
   // Generics Parsing

include/swift/Parse/ParserResult.h

@@ -217,20 +217,6 @@ template <typename T> ParserResult<T>::ParserResult(ParserStatus Status) {
     setHasCodeCompletion();
 }
 
-enum class ConditionalCompilationExprKind {
-  Unknown,
-  Error,
-  OS,
-  Arch,
-  LanguageVersion,
-  CompilerVersion,
-  Binary,
-  Paren,
-  DeclRef,
-  Boolean,
-  Integer
-};
-
 } // namespace swift
 
 #endif // LLVM_SWIFT_PARSER_PARSER_RESULT_H

include/swift/Parse/Scope.h

@@ -54,6 +54,8 @@ class ScopeInfo {
   /// scope.
   void addToScope(ValueDecl *D, Parser &TheParser);
 
+  bool isStaticallyInactiveConfigBlock() const;
+  
   SavedScope saveCurrentScope();
 };
 
@@ -89,6 +91,7 @@ class SavedScope {
   ScopeInfo::ScopedHTDetachedScopeTy HTDetachedScope;
   unsigned Depth;
   ScopeKind Kind;
+  bool IsStaticallyInactiveConfigBlock;
 
   SavedScope() = delete;
   SavedScope(const SavedScope &) = delete;
@@ -100,8 +103,9 @@ class SavedScope {
   ~SavedScope() = default;
 
   SavedScope(ScopeInfo::ScopedHTDetachedScopeTy &&HTDetachedScope,
-             unsigned Depth, ScopeKind Kind)
-    : HTDetachedScope(std::move(HTDetachedScope)), Depth(Depth), Kind(Kind) {}
+             unsigned Depth, ScopeKind Kind, bool IsStaticallyInactiveConfigBlock)
+    : HTDetachedScope(std::move(HTDetachedScope)), Depth(Depth), Kind(Kind),
+      IsStaticallyInactiveConfigBlock(IsStaticallyInactiveConfigBlock) {}
 };
 
 /// Scope - This class represents lexical scopes.  These objects are created
@@ -121,11 +125,13 @@ class Scope {
   unsigned PrevResolvableDepth;
   unsigned Depth;
   ScopeKind Kind;
+  bool IsStaticallyInactiveConfigBlock;
 
   /// \brief Save this scope so that it can be re-entered later.  Transfers the
   /// ownership of the scope frame to returned object.
   SavedScope saveScope() {
-    return SavedScope(HTScope.detach(), Depth, Kind);
+    return SavedScope(HTScope.detach(), Depth, Kind,
+                      IsStaticallyInactiveConfigBlock);
   }
 
   unsigned getDepth() const {
@@ -136,7 +142,7 @@ class Scope {
 
 public:
   /// \brief Create a lexical scope of the specified kind.
-  Scope(Parser *P, ScopeKind SC);
+  Scope(Parser *P, ScopeKind SC, bool IsStaticallyInactiveConfigBlock = false);
 
   /// \brief Re-enter the specified scope, transferring the ownership of the
   /// scope frame to the new object.
@@ -169,6 +175,17 @@ inline ValueDecl *ScopeInfo::lookupValueName(DeclName Name) {
   return Res.second;
 }
 
+inline bool ScopeInfo::isStaticallyInactiveConfigBlock() const {
+  auto scope = CurScope;
+  while (scope) {
+    if (scope->IsStaticallyInactiveConfigBlock) {
+      return true;
+    }
+    scope = scope->PrevScope;
+  }
+  return false;
+}
+
 inline SavedScope ScopeInfo::saveCurrentScope() {
   return CurScope->saveScope();
 }

lib/AST/ASTContext.cpp

@@ -1877,18 +1877,11 @@ void ASTContext::diagnoseAttrsRequiringFoundation(SourceFile &SF) {
   if (ImportsFoundationModule)
     return;
 
-  for (auto &Attr : SF.AttrsRequiringFoundation) {
-    // If we've already diagnosed this attribute, keep going.
-    if (!Attr.second)
-      continue;
-
-    Diags.diagnose(Attr.second->getLocation(),
+  for (auto Attr : SF.AttrsRequiringFoundation) {
+    Diags.diagnose(Attr->getLocation(),
                    diag::attr_used_without_required_module,
-                   Attr.second, Id_Foundation)
-      .highlight(Attr.second->getRangeWithAt());
-
-    // Don't diagnose this again.
-    Attr.second = nullptr;
+                   Attr, Id_Foundation)
+      .highlight(Attr->getRangeWithAt());
   }
 }
 

lib/AST/CMakeLists.txt

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