---

yaml
---
r: 315383
b: refs/heads/master-next
c: 1afd0f7
h: refs/heads/master
i:
  315381: 298db2c
  315379: 7fbb26a
  315375: 02b4e8a

Author: DougGregor

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: 3fe9333052029c114ef816ea805c335eb1ee8a99
-refs/heads/master-next: 73e5a64bd1f3c4a86024a34f062b5dd6c83a3f11
+refs/heads/master-next: 1afd0f7cf757ba6b12d2af0d151eafb022acf439
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-b: 66d897bfcf64a82cb9a87f5e663d889189d06d07

branches/master-next/include/swift/AST/ASTScope.h

@@ -177,8 +177,10 @@ class ASTScopeImpl {
   void addChild(ASTScopeImpl *child, ASTContext &);
   std::vector<ASTScopeImpl *> rescueYoungestChildren(unsigned count);
 
-  virtual std::vector<ASTScopeImpl *> rescueScopesToReuse();
-  virtual void addReusedScopes(ArrayRef<ASTScopeImpl *>);
+  /// When reexpanding, do we always create a new body?
+  virtual NullablePtr<ASTScopeImpl> getParentOfRescuedScopes();
+  std::vector<ASTScopeImpl *> rescueScopesToReuse();
+  void addReusedScopes(ArrayRef<ASTScopeImpl *>);
 
 private:
   void removeChildren();
@@ -201,7 +203,8 @@ class ASTScopeImpl {
   /// InterpolatedStringLiteralExprs and EditorPlaceHolders respond to
   /// getSourceRange with the starting point. But we might be asked to lookup an
   /// identifer within one of them. So, find the real source range of them here.
-  ///   /// FIXME: Alter how these are parsed so getSourceRange is enough.
+  ///
+  /// FIXME: Alter how these are parsed so getSourceRange is enough.
   SourceRange getEffectiveSourceRange(ASTNode) const;
 
   void cacheSourceRangeOfMeAndDescendants(bool omitAssertions = false) const;
@@ -303,6 +306,12 @@ class ASTScopeImpl {
   virtual void beCurrent();
   virtual bool isCurrent() const;
 
+  /// Some scopes can be expanded lazily.
+  /// Such scopes must: not change their source ranges after expansion, and
+  /// their expansion must return an insertion point outside themselves.
+  virtual NullablePtr<ASTScopeImpl> insertionPointForDeferredExpansion();
+  virtual SourceRange sourceRangeForDeferredExpansion() const;
+
 public:
   // Some nodes (VarDecls and Accessors) are created directly from
   // pattern scope code and should neither be deferred nor should
@@ -548,6 +557,10 @@ class Portion {
 
   virtual void beCurrent(IterableTypeScope *) const;
   virtual bool isCurrent(const IterableTypeScope *) const;
+  virtual NullablePtr<ASTScopeImpl>
+  insertionPointForDeferredExpansion(IterableTypeScope *) const;
+  virtual SourceRange
+  sourceRangeForDeferredExpansion(const IterableTypeScope *) const;
   };
 
   // For the whole Decl scope of a GenericType or an Extension
@@ -623,6 +636,10 @@ class IterableTypeBodyPortion final
 
   void beCurrent(IterableTypeScope *) const override;
   bool isCurrent(const IterableTypeScope *) const override;
+  NullablePtr<ASTScopeImpl>
+  insertionPointForDeferredExpansion(IterableTypeScope *) const override;
+  SourceRange
+  sourceRangeForDeferredExpansion(const IterableTypeScope *) const override;
 };
 
 /// GenericType or Extension scope
@@ -702,7 +719,6 @@ class IterableTypeScope : public GenericTypeScope {
   /// Because of \c parseDelayedDecl members can get added after the tree is
   /// constructed, and they can be out of order. Detect this happening by
   /// remembering the member count.
-  /// TODO: unify with \c numberOfDeclsAlreadySeen
   unsigned memberCount = 0;
 
 public:
@@ -721,6 +737,8 @@ class IterableTypeScope : public GenericTypeScope {
 public:
   void makeBodyCurrent();
   bool isBodyCurrent() const;
+  NullablePtr<ASTScopeImpl> insertionPointForDeferredExpansion() override;
+  SourceRange sourceRangeForDeferredExpansion() const override;
 };
 
 class NominalTypeScope final : public IterableTypeScope {
@@ -958,8 +976,7 @@ class AbstractFunctionBodyScope : public ASTScopeImpl {
   Decl *getDecl() const { return decl; }
   static bool isAMethod(const AbstractFunctionDecl *);
 
-  std::vector<ASTScopeImpl *> rescueScopesToReuse() override;
-  void addReusedScopes(ArrayRef<ASTScopeImpl *>) override;
+  NullablePtr<ASTScopeImpl> getParentOfRescuedScopes() override;
 
 protected:
   bool lookupLocalsOrMembers(ArrayRef<const ASTScopeImpl *>,
@@ -1122,7 +1139,6 @@ class PatternEntryDeclScope final : public AbstractPatternEntryScope {
   SourceRange
   getChildlessSourceRange(bool omitAssertions = false) const override;
 
-  static bool isHandledSpecially(const ASTNode n);
   NullablePtr<const void> getReferrent() const override;
 
 protected:
@@ -1372,8 +1388,7 @@ class TopLevelCodeScope final : public ASTScopeImpl {
   Decl *getDecl() const { return decl; }
   NullablePtr<const void> getReferrent() const override;
 
-  std::vector<ASTScopeImpl *> rescueScopesToReuse() override;
-  void addReusedScopes(ArrayRef<ASTScopeImpl *>) override;
+  NullablePtr<ASTScopeImpl> getParentOfRescuedScopes() override;
 };
 
 /// The \c _@specialize attribute.

branches/master-next/include/swift/AST/ClangModuleLoader.h

@@ -14,7 +14,6 @@
 #define SWIFT_AST_CLANG_MODULE_LOADER_H
 
 #include "swift/AST/ModuleLoader.h"
-#include "swift/Demangling/Demangle.h"
 
 namespace clang {
 class ASTContext;
@@ -28,11 +27,24 @@ namespace swift {
 class DeclContext;
 class VisibleDeclConsumer;
 
+/// Represents the different namespaces for types in C.
+///
+/// A simplified version of clang::Sema::LookupKind.
+enum class ClangTypeKind {
+  Typedef,
+  ObjCClass = Typedef,
+  /// Structs, enums, and unions.
+  Tag,
+  ObjCProtocol,
+};
+
 class ClangModuleLoader : public ModuleLoader {
 private:
   virtual void anchor();
+
 protected:
   using ModuleLoader::ModuleLoader;
+
 public:
   virtual clang::ASTContext &getClangASTContext() const = 0;
   virtual clang::Preprocessor &getClangPreprocessor() const = 0;
@@ -56,37 +68,11 @@ class ClangModuleLoader : public ModuleLoader {
   ///
   /// This routine is used for various hacks that are only permitted within
   /// overlays of imported modules, e.g., Objective-C bridging conformances.
-  virtual bool isInOverlayModuleForImportedModule(
-                                            const DeclContext *overlayDC,
-                                            const DeclContext *importedDC) = 0;
-
-  /// Look for declarations associated with the given name.
-  ///
-  /// \param name The name we're searching for.
-  virtual void lookupValue(DeclName name, VisibleDeclConsumer &consumer) {}
-
-  /// Look up a type declaration by its Clang name.
-  ///
-  /// Note that this method does no filtering. If it finds the type in a loaded
-  /// module, it returns it. This is intended for use in reflection / debugging
-  /// contexts where access is not a problem.
-  virtual void lookupTypeDecl(StringRef clangName, Demangle::Node::Kind kind,
-                              llvm::function_ref<void(TypeDecl *)> receiver) {}
-
-  /// Look up type a declaration synthesized by the Clang importer itself, using
-  /// a "related entity kind" to determine which type it should be. For example,
-  /// this can be used to find the synthesized error struct for an
-  /// NS_ERROR_ENUM.
-  ///
-  /// Note that this method does no filtering. If it finds the type in a loaded
-  /// module, it returns it. This is intended for use in reflection / debugging
-  /// contexts where access is not a problem.
-  virtual void
-  lookupRelatedEntity(StringRef clangName, StringRef relatedEntityKind,
-                      llvm::function_ref<void(TypeDecl *)> receiver) {}
+  virtual bool
+  isInOverlayModuleForImportedModule(const DeclContext *overlayDC,
+                                     const DeclContext *importedDC) = 0;
 };
 
 } // namespace swift
 
 #endif // LLVM_SWIFT_AST_CLANG_MODULE_LOADER_H
-

branches/master-next/include/swift/AST/Decl.h

@@ -1523,6 +1523,17 @@ class GenericContext : private _GenericContext, public DeclContext {
 
   /// Determine whether this context has generic parameters
   /// of its own.
+  ///
+  /// \code
+  /// class C<T> {
+  ///   func f1() {}    // isGeneric == false
+  ///   func f2<T>() {} // isGeneric == true
+  /// }
+  ///
+  /// protocol P { // isGeneric == true due to implicit Self param
+  ///   func p()   // isGeneric == false
+  /// }
+  /// \endcode
   bool isGeneric() const { return GenericParams != nullptr; }
 
   /// Retrieve the trailing where clause for this extension, if any.

branches/master-next/include/swift/AST/DiagnosticsParse.def

@@ -163,7 +163,7 @@ ERROR(lex_illegal_multiline_string_end,none,
       "multi-line string literal closing delimiter must begin on a new line", ())
 ERROR(lex_multiline_string_indent_inconsistent,none,
       "%select{unexpected space in|unexpected tab in|insufficient}2 indentation of "
-      "%select{line|next %1 lines}0 in multi-line string literal", 
+      "%select{line|next %1 lines}0 in multi-line string literal",
       (bool, unsigned, unsigned))
 NOTE(lex_multiline_string_indent_should_match_here,none,
       "should match %select{space|tab}0 here", (unsigned))
@@ -252,7 +252,7 @@ ERROR(cskeyword_not_attribute,none,
       "'%0' is a declaration modifier, not an attribute", (StringRef))
 
 ERROR(decl_already_static,none,
-      "%0 specified twice", (StaticSpellingKind))
+      "%0 cannot appear after another 'static' or 'class' keyword", (StaticSpellingKind))
 
 ERROR(enum_case_dot_prefix,none,
       "extraneous '.' in enum 'case' declaration", ())
@@ -881,7 +881,7 @@ WARNING(parameter_extraneous_double_up,none,
         "extraneous duplicate parameter name; %0 already has an argument "
         "label", (Identifier))
 ERROR(parameter_operator_keyword_argument,none,
-      "%select{operator|closure|enum case}0 cannot have keyword arguments", 
+      "%select{operator|closure|enum case}0 cannot have keyword arguments",
       (unsigned))
 
 ERROR(parameter_unnamed,none,

branches/master-next/include/swift/Basic/LangOptions.h

@@ -115,9 +115,6 @@ namespace swift {
     /// Only used by lldb-moduleimport-test.
     bool EnableMemoryBufferImporter = false;
 
-    /// Enable the DWARFImporter. Only used by lldb-moduleimport-test.
-    bool EnableDWARFImporter = false;
-    
     /// Allows using identifiers with a leading dollar.
     bool EnableDollarIdentifiers = false;
 
@@ -271,6 +268,9 @@ namespace swift {
     /// whether it is. The warning is useful for testing.
     bool WarnIfASTScopeLookup = false;
 
+    /// Build the ASTScope tree lazily
+    bool LazyASTScopes = false;
+
     /// Whether to use the import as member inference system
     ///
     /// When importing a global, try to infer whether we can import it as a

branches/master-next/include/swift/ClangImporter/ClangImporter.h

@@ -60,22 +60,28 @@ class TypeDecl;
 class VisibleDeclConsumer;
 enum class SelectorSplitKind;
 
-/// Represents the different namespaces for types in C.
+/// This interface is implemented by LLDB to serve as a fallback when Clang
+/// modules can't be imported from source in the debugger.
 ///
-/// A simplified version of clang::Sema::LookupKind.
-enum class ClangTypeKind {
-  Typedef,
-  ObjCClass = Typedef,
-  /// Structs, enums, and unions.
-  Tag,
-  ObjCProtocol,
+/// During compile time, ClangImporter-imported Clang modules are compiled with
+/// -gmodules, which emits a DWARF rendition of all types defined in the module
+/// into the .pcm file. On Darwin, these types can be collected by
+/// dsymutil. This delegate allows DWARFImporter to ask LLDB to look up a Clang
+/// type by name, synthesize a Clang AST from it. DWARFImporter then hands this
+/// Clang AST to ClangImporter to import the type into Swift.
+class DWARFImporterDelegate {
+public:
+  virtual ~DWARFImporterDelegate() {}
+  /// Perform a qualified lookup of a Clang type with this name.
+  /// \param kind  Only return results with this type kind.
+  virtual void lookupValue(StringRef name, llvm::Optional<ClangTypeKind> kind,
+                           SmallVectorImpl<clang::Decl *> &results) {}
 };
 
 /// Class that imports Clang modules into Swift, mapping directly
 /// from Clang ASTs over to Swift ASTs.
 class ClangImporter final : public ClangModuleLoader {
   friend class ClangModuleUnit;
-  friend class DWARFImporter;
 
 public:
   class Implementation;
@@ -84,8 +90,11 @@ class ClangImporter final : public ClangModuleLoader {
   Implementation &Impl;
 
   ClangImporter(ASTContext &ctx, const ClangImporterOptions &clangImporterOpts,
-                DependencyTracker *tracker);
+                DependencyTracker *tracker,
+                std::unique_ptr<DWARFImporterDelegate> dwarfImporterDelegate);
 
+  ModuleDecl *loadModuleClang(SourceLoc importLoc,
+                              ArrayRef<std::pair<Identifier, SourceLoc>> path);
 public:
   /// Create a new Clang importer that can import a suitable Clang
   /// module into the given ASTContext.
@@ -100,13 +109,15 @@ class ClangImporter final : public ClangModuleLoader {
   ///
   /// \param tracker The object tracking files this compilation depends on.
   ///
+  /// \param dwarfImporterDelegate A helper object that can synthesize
+  /// Clang Decls from debug info. Used by LLDB.
+  ///
   /// \returns a new Clang module importer, or null (with a diagnostic) if
   /// an error occurred.
   static std::unique_ptr<ClangImporter>
-  create(ASTContext &ctx,
-         const ClangImporterOptions &importerOpts,
-         std::string swiftPCHHash = "",
-         DependencyTracker *tracker = nullptr);
+  create(ASTContext &ctx, const ClangImporterOptions &importerOpts,
+         std::string swiftPCHHash = "", DependencyTracker *tracker = nullptr,
+         std::unique_ptr<DWARFImporterDelegate> dwarfImporterDelegate = {});
 
   ClangImporter(const ClangImporter &) = delete;
   ClangImporter(ClangImporter &&) = delete;
@@ -161,15 +172,15 @@ class ClangImporter final : public ClangModuleLoader {
   /// Look for declarations associated with the given name.
   ///
   /// \param name The name we're searching for.
-  void lookupValue(DeclName name, VisibleDeclConsumer &consumer) override;
+  void lookupValue(DeclName name, VisibleDeclConsumer &consumer);
 
   /// Look up a type declaration by its Clang name.
   ///
   /// Note that this method does no filtering. If it finds the type in a loaded
   /// module, it returns it. This is intended for use in reflection / debugging
   /// contexts where access is not a problem.
-  void lookupTypeDecl(StringRef clangName, Demangle::Node::Kind kind,
-                      llvm::function_ref<void(TypeDecl*)> receiver) override;
+  void lookupTypeDecl(StringRef clangName, ClangTypeKind kind,
+                      llvm::function_ref<void(TypeDecl *)> receiver);
 
   /// Look up type a declaration synthesized by the Clang importer itself, using
   /// a "related entity kind" to determine which type it should be. For example,
@@ -180,8 +191,9 @@ class ClangImporter final : public ClangModuleLoader {
   /// module, it returns it. This is intended for use in reflection / debugging
   /// contexts where access is not a problem.
   void
-  lookupRelatedEntity(StringRef clangName, StringRef relatedEntityKind,
-                      llvm::function_ref<void(TypeDecl *)> receiver) override;
+  lookupRelatedEntity(StringRef clangName, ClangTypeKind kind,
+                      StringRef relatedEntityKind,
+                      llvm::function_ref<void(TypeDecl *)> receiver);
 
   /// Look for textually included declarations from the bridging header.
   ///