Restore local type declarations list

Author: CodaFi

include/swift/AST/Decl.h

@@ -584,12 +584,8 @@ class alignas(1 << DeclAlignInBits) Decl {
 
     /// Whether this decl is missing its closing '#endif'.
     unsigned HadMissingEnd : 1;
-
-    /// Whether this condition has been resolved either statically by Parse or
-    /// later by Condition Resolution.
-    unsigned HasBeenResolved : 1;
   };
-  enum { NumIfConfigDeclBits = NumDeclBits + 2 };
+  enum { NumIfConfigDeclBits = NumDeclBits + 1 };
   static_assert(NumIfConfigDeclBits <= 32, "fits in an unsigned");
 
 protected:
@@ -1932,8 +1928,7 @@ struct IfConfigDeclClause {
 
   IfConfigDeclClause(SourceLoc Loc, Expr *Cond, ArrayRef<Decl*> Members,
                      bool isActive)
-    : Loc(Loc), Cond(Cond), Members(Members), isActive(isActive) {
-  }
+    : Loc(Loc), Cond(Cond), Members(Members), isActive(isActive) {}
 };
 
 

include/swift/AST/DiagnosticsParse.def

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

include/swift/Parse/Parser.h

@@ -59,11 +59,10 @@ namespace swift {
     TopLevelCode,
     /// The top-level of a file, when in parse-as-library mode.
     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,
+    /// The body of the inactive clause of an #if/#else/#endif block
+    InactiveConditionalBlock,
+    /// The body of the active clause of an #if/#else/#endif block
+    ActiveConditionalBlock,
   };
 
 
@@ -620,10 +619,6 @@ class Parser {
                                    BraceItemListKind::Brace);
   ParserResult<BraceStmt> parseBraceItemList(Diag<> ID);
 
-  void parseIfConfigClauseElements(bool isInactive,
-                                   BraceItemListKind Kind,
-                                   SmallVectorImpl<ASTNode> &Elements);
-  
   void parseTopLevelCodeDeclDelayed();
 
   //===--------------------------------------------------------------------===//

include/swift/Parse/Scope.h

@@ -54,7 +54,7 @@ class ScopeInfo {
   /// scope.
   void addToScope(ValueDecl *D, Parser &TheParser);
 
-  bool isStaticallyInactiveConfigBlock() const;
+  bool isInactiveConfigBlock() const;
 
   SavedScope saveCurrentScope();
 };
@@ -91,7 +91,7 @@ class SavedScope {
   ScopeInfo::ScopedHTDetachedScopeTy HTDetachedScope;
   unsigned Depth;
   ScopeKind Kind;
-  bool IsStaticallyInactiveConfigBlock;
+  bool IsInactiveConfigBlock;
 
   SavedScope() = delete;
   SavedScope(const SavedScope &) = delete;
@@ -103,9 +103,9 @@ class SavedScope {
   ~SavedScope() = default;
 
   SavedScope(ScopeInfo::ScopedHTDetachedScopeTy &&HTDetachedScope,
-             unsigned Depth, ScopeKind Kind, bool IsStaticallyInactiveConfigBlock)
+             unsigned Depth, ScopeKind Kind, bool isInactiveConfigBlock)
     : HTDetachedScope(std::move(HTDetachedScope)), Depth(Depth), Kind(Kind),
-      IsStaticallyInactiveConfigBlock(IsStaticallyInactiveConfigBlock) {}
+      IsInactiveConfigBlock(isInactiveConfigBlock) {}
 };
 
 /// Scope - This class represents lexical scopes.  These objects are created
@@ -125,13 +125,12 @@ class Scope {
   unsigned PrevResolvableDepth;
   unsigned Depth;
   ScopeKind Kind;
-  bool IsStaticallyInactiveConfigBlock;
+  bool IsInactiveConfigBlock;
 
   /// \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,
-                      IsStaticallyInactiveConfigBlock);
+    return SavedScope(HTScope.detach(), Depth, Kind, IsInactiveConfigBlock);
   }
 
   unsigned getDepth() const {
@@ -142,7 +141,7 @@ class Scope {
 
 public:
   /// \brief Create a lexical scope of the specified kind.
-  Scope(Parser *P, ScopeKind SC, bool IsStaticallyInactiveConfigBlock = false);
+  Scope(Parser *P, ScopeKind SC, bool isInactiveConfigBlock = false);
 
   /// \brief Re-enter the specified scope, transferring the ownership of the
   /// scope frame to the new object.
@@ -175,15 +174,10 @@ 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 bool ScopeInfo::isInactiveConfigBlock() const {
+  if (!CurScope)
+    return false;
+  return CurScope->IsInactiveConfigBlock;
 }
 
 inline SavedScope ScopeInfo::saveCurrentScope() {

lib/Parse/ParseDecl.cpp

@@ -1850,8 +1850,9 @@ void Parser::setLocalDiscriminator(ValueDecl *D) {
   if (!CurLocalContext || !D->getDeclContext()->isLocalContext())
     return;
 
-  if (getScopeInfo().isStaticallyInactiveConfigBlock())
-    return;
+  if (auto TD = dyn_cast<TypeDecl>(D))
+    if (!getScopeInfo().isInactiveConfigBlock())
+      SF.LocalTypeDecls.insert(TD);
 
   Identifier name = D->getName();
   unsigned discriminator = CurLocalContext->claimNextNamedDiscriminator(name);
@@ -2217,6 +2218,15 @@ ParserStatus Parser::parseDecl(ParseDeclOptions Flags,
     break;
   }
 
+  if (auto SF = CurDeclContext->getParentSourceFile()) {
+    if (!getScopeInfo().isInactiveConfigBlock()) {
+      for (auto Attr : Attributes) {
+        if (isa<ObjCAttr>(Attr) || isa<DynamicAttr>(Attr))
+          SF->AttrsRequiringFoundation.insert(Attr);
+      }
+    }
+  }
+
   if (FoundCCTokenInAttr) {
     if (CodeCompletion) {
       CodeCompletion->completeDeclAttrKeyword(DeclResult.getPtrOrNull(),

lib/Parse/ParseStmt.cpp

@@ -157,8 +157,8 @@ static bool isTerminatorForBraceItemListKind(const Token &Tok,
     return false;
   case BraceItemListKind::TopLevelLibrary:
     return false;
-  case BraceItemListKind::ConditionalBlock:
-  case BraceItemListKind::StaticallyInactiveConditionalBlock:
+  case BraceItemListKind::ActiveConditionalBlock:
+  case BraceItemListKind::InactiveConditionalBlock:
     return Tok.isNot(tok::pound_else) && Tok.isNot(tok::pound_endif) &&
            Tok.isNot(tok::pound_elseif);
   }
@@ -235,17 +235,18 @@ ParserStatus Parser::parseBraceItems(SmallVectorImpl<ASTNode> &Entries,
 
   bool IsTopLevel = (Kind == BraceItemListKind::TopLevelCode) ||
                     (Kind == BraceItemListKind::TopLevelLibrary);
-  bool isConditionalBlock
-    = (ConditionalBlockKind == BraceItemListKind::ConditionalBlock) ||
-      (ConditionalBlockKind == BraceItemListKind::StaticallyInactiveConditionalBlock);
+  bool isActiveConditionalBlock =
+    ConditionalBlockKind == BraceItemListKind::ActiveConditionalBlock;
+  bool isConditionalBlock = isActiveConditionalBlock ||
+    ConditionalBlockKind == BraceItemListKind::InactiveConditionalBlock;
 
-  // If we're not parsing an inactive #if block, form a new lexical scope.
+  // If we're not parsing an active #if block, form a new lexical scope.
   Optional<Scope> initScope;
-  bool isInactiveConditionalBlock =
-    ConditionalBlockKind == BraceItemListKind::StaticallyInactiveConditionalBlock;
-  if (!isInactiveConditionalBlock) {
+  if (!isActiveConditionalBlock) {
     auto scopeKind =  IsTopLevel ? ScopeKind::TopLevel : ScopeKind::Brace;
-    initScope.emplace(this, scopeKind, isInactiveConditionalBlock);
+    initScope.emplace(this, scopeKind,
+                      ConditionalBlockKind ==
+                        BraceItemListKind::InactiveConditionalBlock);
   }
 
   ParserStatus BraceItemsStatus;
@@ -608,16 +609,6 @@ ParserResult<BraceStmt> Parser::parseBraceItemList(Diag<> ID) {
                           BraceStmt::create(Context, LBLoc, Entries, RBLoc));
 }
 
-/// \brief Parses the elements in active or inactive if config clauses.
-void Parser::parseIfConfigClauseElements(bool isInactive,
-                                         BraceItemListKind Kind,
-                                         SmallVectorImpl<ASTNode> &Elements) {
-  parseBraceItems(Elements, Kind,
-                  isInactive
-                    ? BraceItemListKind::StaticallyInactiveConditionalBlock
-                    : BraceItemListKind::ConditionalBlock);
-}
-
 /// parseStmtBreak
 ///
 ///   stmt-break:
@@ -1641,8 +1632,7 @@ Parser::classifyConditionalCompilationExpr(Expr *condition,
         !fnName.equals("_endian") &&
         !fnName.equals("_runtime") &&
         !fnName.equals("swift") &&
-        !fnName.equals("_compiler_version") &&
-        !fnName.equals("canImport")) {
+        !fnName.equals("_compiler_version")) {
       D.diagnose(CE->getLoc(), diag::unsupported_platform_condition_expression);
       return ConditionalCompilationExprState::error();
     }
@@ -1736,11 +1726,6 @@ Parser::classifyConditionalCompilationExpr(Expr *condition,
             D.diagnose(UDRE->getLoc(), diag::unknown_platform_condition_argument,
                        "endianness", fnName);
           }
-        } else if (fnName == "canImport") {
-          bool result =
-            Context.canImportModule({ argumentIdent, UDRE->getLoc() });
-          return {result,
-            ConditionalCompilationExprKind::Import};
         }
 
         // FIXME: Perform the replacement macOS -> OSX elsewhere.
@@ -1819,10 +1804,12 @@ ParserResult<Stmt> Parser::parseStmtIfConfig(BraceItemListKind Kind) {
     }
 
     SmallVector<ASTNode, 16> Elements;
-    if (ConfigState.shouldParse())
-      parseIfConfigClauseElements(ConfigState.isConditionActive(), Kind,
-                                  Elements);
-    else {
+    if (ConfigState.shouldParse()) {
+      parseBraceItems(Elements, Kind,
+                      ConfigState.isConditionActive()
+                        ? BraceItemListKind::ActiveConditionalBlock
+                        : BraceItemListKind::InactiveConditionalBlock);
+    } else {
       DiagnosticTransaction DT(Diags);
       skipUntilConditionalBlockClose();
       DT.abort();

lib/Parse/Scope.cpp

@@ -52,18 +52,18 @@ static bool isResolvableScope(ScopeKind SK) {
   llvm_unreachable("Unhandled ScopeKind in switch.");
 }
 
-Scope::Scope(Parser *P, ScopeKind SC, bool IsStaticallyInactiveConfigBlock)
+Scope::Scope(Parser *P, ScopeKind SC, bool isInactiveConfigBlock)
   : SI(P->getScopeInfo()),
     HTScope(SI.HT, SI.CurScope ? &SI.CurScope->HTScope : nullptr),
     PrevScope(SI.CurScope),
     PrevResolvableDepth(SI.ResolvableDepth),
     Kind(SC),
-    IsStaticallyInactiveConfigBlock(IsStaticallyInactiveConfigBlock) {
+    IsInactiveConfigBlock(isInactiveConfigBlock) {
   assert(PrevScope || Kind == ScopeKind::TopLevel);
 
   if (SI.CurScope) {
     Depth = SI.CurScope->Depth + 1;
-    IsStaticallyInactiveConfigBlock |= SI.CurScope->IsStaticallyInactiveConfigBlock;
+    IsInactiveConfigBlock |= SI.CurScope->IsInactiveConfigBlock;
   } else {
     Depth = 0;
   }
@@ -79,7 +79,7 @@ Scope::Scope(Parser *P, SavedScope &&SS):
     PrevResolvableDepth(SI.ResolvableDepth),
     Depth(SS.Depth),
     Kind(SS.Kind),
-    IsStaticallyInactiveConfigBlock(SS.IsStaticallyInactiveConfigBlock) {
+    IsInactiveConfigBlock(SS.IsInactiveConfigBlock) {
 
     SI.CurScope = this;
     if (!isResolvableScope(Kind))

test/ClangImporter/MixedSource/can_import_objc_idempotent.swift

@@ -13,6 +13,7 @@
 // RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk-nosource -I %t) -I %S/../Inputs/custom-modules -typecheck %s -verify
 
 // REQUIRES: objc_interop
+// REQUIRES: can_import
 
 // Test that 'canImport(Foo)' directives do not open symbols from 'Foo' into the
 // current module.  Only an 'import Foo' statement should do this.

test/ClangImporter/can_import_missing_requirement.swift

@@ -1,6 +1,7 @@
 // RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -typecheck -I %S/Inputs/missing-requirement %s -verify
 
 // REQUIRES: objc_interop
+// REQUIRES: can_import
 
 class Unique {}
 

test/Parse/ConditionalCompilation/basicParseErrors.swift

@@ -8,7 +8,7 @@ var x = 0
 var y = 0
 #endif
 
-#if foo(BAR) // expected-error {{unexpected platform condition (expected 'canImport', 'os', 'arch', or 'swift')}}
+#if foo(BAR) // expected-error {{unexpected platform condition (expected 'os', 'arch', or 'swift')}}
 var z = 0
 #endif
 
@@ -28,7 +28,7 @@ func h() {}
 #endif /* bbb */
 
 #if foo.bar() 
-      .baz() // expected-error {{unexpected platform condition (expected 'canImport', 'os', 'arch', or 'swift')}}
+      .baz() // expected-error {{unexpected platform condition (expected 'os', 'arch', or 'swift')}}
 
 #endif
 
@@ -45,11 +45,6 @@ struct S {
   #endif
 }
 
-#if canImport(01101101_01101111_01101111_01100100) // expected-error {{unexpected platform condition argument: expected identifier}}
-#elseif canImport(Foundation) ** FOO // expected-error{{expected '&&' or '||' expression}}
-#else
-#endif
-
 #if FOO
 #else
 #else  // expected-error {{further conditions after #else are unreachable}}

test/Parse/ConditionalCompilation/can_import.swift

@@ -1,6 +1,8 @@
 // RUN: %target-typecheck-verify-swift -parse-as-library
 // RUN: %target-typecheck-verify-swift -D WITH_PERFORM -primary-file %s %S/Inputs/can_import_nonprimary_file.swift
 
+// REQUIRES: can_import
+
 public struct LibraryDependentBool : ExpressibleByBooleanLiteral {
 #if canImport(Swift)
   var _description: String

test/Parse/ConditionalCompilation/can_import_idempotent.swift

@@ -4,6 +4,8 @@
 // RUN: echo "public var dummyVar = Int()" | %target-swift-frontend -module-name DummyModule -emit-module -o %t -
 // RUN: %target-swift-frontend -typecheck -verify -I %t %s
 
+// REQUIRES: can_import
+
 #if canImport(DummyModule)
 print(DummyModule.dummyVar) // expected-error {{use of unresolved identifier 'DummyModule'}}
 print(dummyVar) // expected-error {{use of unresolved identifier 'dummyVar'}}

test/Parse/ConditionalCompilation/can_import_sdk.swift

@@ -1,6 +1,7 @@
 // RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -typecheck -verify %s
 
 // REQUIRES: objc_interop
+// REQUIRES: can_import
 
 class Unique {} 
 

validation-test/compiler_crashers_fixed/28611-isa-x-val-cast-ty-argument-of-incompatible-type.swift

@@ -6,5 +6,4 @@
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 
 // RUN: not %target-swift-frontend %s -emit-ir
-// REQUIRES: asserts
 #if0=0