Merge remote-tracking branch 'upstream/master' into SR-755-linux-fatal-stacktrace-symbolication

Author: gmilos

.pep8

@@ -1,2 +1,2 @@
 [flake8]
-filename = *.py,80+-check,Benchmark_Driver,Benchmark_DTrace.in,Benchmark_GuardMalloc.in,Benchmark_RuntimeLeaksRunner.in,build-script,check-incremental,gyb,line-directive,mock-distcc,ns-html2rst,recursive-lipo,rth,run-test,submit-benchmark-results,update-checkout,viewcfg,backtrace-check,symbolicate-linux-fatal
+filename = *.py,80+-check,Benchmark_Driver,Benchmark_DTrace.in,Benchmark_GuardMalloc.in,Benchmark_RuntimeLeaksRunner.in,build-script,check-incremental,gyb,line-directive,mock-distcc,ns-html2rst,recursive-lipo,rth,run-test,submit-benchmark-results,update-checkout,viewcfg,backtrace-check,coverage-build-db,coverage-generate-data,coverage-touch-tests,symbolicate-linux-fatal

CHANGELOG.md

@@ -741,6 +741,7 @@ Globals
   global ::= 'Mm' type                   // class metaclass
   global ::= 'Mn' nominal-type           // nominal type descriptor
   global ::= 'Mp' protocol               // protocol descriptor
+  global ::= 'MR' remote-reflection-record // metadata for remote mirrors
   global ::= 'PA' .*                     // partial application forwarder
   global ::= 'PAo' .*                    // ObjC partial application forwarder
   global ::= 'w' value-witness-kind type // value witness
@@ -822,6 +823,10 @@ Globals
   addressor-kind ::= 'o'                 // owning addressor (native owner)
   addressor-kind ::= 'p'                 // pinning addressor (native owner)
 
+  remote-reflection-record ::= 'f' type                  // field descriptor
+  remote-reflection-record ::= 'a' protocol-conformance  // associated type descriptor
+  remote-reflection-record ::= 'b' type                  // builtin type descriptor
+
 An ``entity`` starts with a ``nominal-type-kind`` (``[COPV]``), a
 substitution (``[Ss]``) of a nominal type, or an ``entity-kind``
 (``[FIiv]``).

docs/ABI.rst

@@ -687,7 +687,7 @@ Associated type inference is a useful feature. It's used throughout the standard
 
 ## Existentials
 
-Existentials aren't really generics per se, but the two systems are closely intertwined due to their mutable dependence on protocols.
+Existentials aren't really generics per se, but the two systems are closely intertwined due to their mutual dependence on protocols.
 
 ### Generalized existentials
 

docs/GenericsManifesto.md

@@ -347,9 +347,14 @@ A type ``T`` is a *legal SIL type* if:
 - it is a function type which satisfies the constraints (below) on
   function types in SIL,
 
+- it is a metatype type which describes its representation,
+
 - it is a tuple type whose element types are legal SIL types,
 
-- it is a legal Swift type that is not a function, tuple, or l-value type, or
+- it is ``Optional<U>``, where ``U`` is a legal SIL type,
+
+- it is a legal Swift type that is not a function, tuple, optional,
+  metatype, or l-value type, or
 
 - it is a ``@box`` containing a legal SIL type.
 
@@ -394,6 +399,22 @@ a box containing a mutable value of type ``T``. Boxes always use Swift-native
 reference counting, so they can be queried for uniqueness and cast to the
 ``Builtin.NativeObject`` type.
 
+Metatype Types
+``````````````
+
+A concrete or existential metatype in SIL must describe its representation.
+This can be:
+
+- ``@thin``, meaning that it requires no storage and thus necessarily
+  represents an exact type (only allowed for concrete metatypes);
+
+- ``@thick``, meaning that it stores a reference to a type or (if a
+  concrete class) a subclass of that type; or
+
+- ``@objc``, meaning that it stores a reference to a class type (or a
+  subclass thereof) using an Objective-C class object representation
+  rather than the native Swift type-object representation.
+
 Function Types
 ``````````````
 

docs/SIL.rst

@@ -230,10 +230,6 @@ class ASTContext {
 
   /// Cache of remapped types (useful for diagnostics).
   llvm::StringMap<Type> RemappedTypes;
-  
-  /// Cache for generic mangling signatures.
-  llvm::DenseMap<std::pair<GenericSignature*, ModuleDecl*>,
-                 CanGenericSignature> ManglingSignatures;
 
 private:
   /// \brief The current generation number, which reflects the number of
@@ -838,12 +834,6 @@ class ASTContext {
   ArchetypeBuilder *getOrCreateArchetypeBuilder(CanGenericSignature sig,
                                                 ModuleDecl *mod);
 
-  /// Set the stored archetype builder for the given canonical generic
-  /// signature and module.
-  void setArchetypeBuilder(CanGenericSignature sig,
-                           ModuleDecl *mod,
-                           std::unique_ptr<ArchetypeBuilder> builder);
-
   /// Retrieve the inherited name set for the given class.
   const InheritedNameSet *getAllPropertyNames(ClassDecl *classDecl,
                                               bool forInstance);

include/swift/AST/ASTContext.h

@@ -51,6 +51,7 @@ class Stmt;
 class StmtConditionElement;
 class SwitchStmt;
 class TopLevelCodeDecl;
+class TypeDecl;
 class WhileStmt;
 
 /// Describes kind of scope that occurs within the AST.
@@ -61,6 +62,10 @@ enum class ASTScopeKind : uint8_t {
   Preexpanded,
   /// A source file, which is the root of a scope.
   SourceFile,
+  /// The declaration of a type.
+  TypeDecl,
+  /// The generic parameters of an extension declaration.
+  ExtensionGenericParams,
   /// The body of a type or extension thereof.
   TypeOrExtensionBody,
   /// The generic parameters of a declaration.
@@ -71,17 +76,18 @@ enum class ASTScopeKind : uint8_t {
   AbstractFunctionParams,
   /// The default argument for a parameter.
   DefaultArgument,
+  /// The body of a function.
+  AbstractFunctionBody,
   /// A specific pattern binding.
   PatternBinding,
   /// The scope introduced for an initializer of a pattern binding.
   PatternInitializer,
-  /// The scope introduced by a particular clause in a pattern binding
-  /// declaration.
+  /// The scope following a particular clause in a pattern binding declaration,
+  /// which is the outermost scope in which the variables introduced by that
+  /// clause will be visible.
   AfterPatternBinding,
   /// The scope introduced by a brace statement.
   BraceStmt,
-  /// The scope introduced by a local declaration.
-  LocalDeclaration,
   /// Node describing an "if" statement.
   IfStmt,
   /// The scope introduced by a conditional clause in an if/guard/while
@@ -150,8 +156,27 @@ class ASTScope {
   /// whether the children of this node have already been expanded.
   mutable llvm::PointerIntPair<const ASTScope *, 1, bool> parentAndExpanded;
 
-  /// The cached source range.
-  mutable SourceRange CachedSourceRange;
+  /// Describes the kind of continuation stored in the continuation field.
+  enum class ContinuationKind {
+    /// The continuation is historical: if the continuation is non-null, we
+    /// preserve it so we know which scope to look at to compute the end of the
+    /// source range.
+    Historical = 0,
+    /// The continuation is active.
+    Active = 1,
+    /// The continuation stored in the pointer field is active, and replaced a
+    /// \c SourceFile continuation.
+    ActiveThenSourceFile = 2,
+  };
+
+  /// The scope from which the continuation child nodes will be populated.
+  ///
+  /// The enumeration bits indicate whether the continuation pointer represents
+  /// an active continuation (vs. a historical one) and whether the former
+  /// continuation was for a \c SourceFile (which can be stacked behind another
+  /// continuation).
+  mutable llvm::PointerIntPair<const ASTScope *, 2, ContinuationKind>
+    continuation = { nullptr, ContinuationKind::Historical };
 
   /// Union describing the various kinds of AST nodes that can introduce
   /// scopes.
@@ -167,8 +192,15 @@ class ASTScope {
       mutable unsigned nextElement;
     } sourceFile;
 
+    /// A type declaration, for \c kind == ASTScopeKind::TypeDecl.
+    TypeDecl *typeDecl;
+
+    /// An extension declaration, for
+    /// \c kind == ASTScopeKind::ExtensionGenericParams.
+    ExtensionDecl *extension;
+
     /// An iterable declaration context, which covers nominal type declarations
-    /// and extensions.
+    /// and extension bodies.
     ///
     /// For \c kind == ASTScopeKind::TypeOrExtensionBody.
     IterableDeclContext *iterableDeclContext;
@@ -185,10 +217,11 @@ class ASTScope {
       unsigned index;
     } genericParams;
 
-    /// An abstract function, for \c kind == ASTScopeKind::AbstractFunctionDecl.
+    /// An abstract function, for \c kind == ASTScopeKind::AbstractFunctionDecl
+    /// or \c kind == ASTScopeKind::AbstractFunctionBody.
     AbstractFunctionDecl *abstractFunction;
 
-    /// An parameter for an abstract function (init/func/deinit).
+    /// A parameter for an abstract function (init/func/deinit).
     ///
     /// For \c kind == ASTScopeKind::AbstractFunctionParams.
     struct {
@@ -222,11 +255,6 @@ class ASTScope {
       mutable unsigned nextElement;
     } braceStmt;
 
-    /// The declaration introduced within a local scope.
-    ///
-    /// For \c kind == ASTScopeKind::LocalDeclaration.
-    Decl *localDeclaration;
-
     /// The 'if' statement, for \c kind == ASTScopeKind::IfStmt.
     IfStmt *ifStmt;
 
@@ -286,6 +314,26 @@ class ASTScope {
   /// Child scopes, sorted by source range.
   mutable SmallVector<ASTScope *, 4> storedChildren;
 
+  /// Retrieve the active continuation.
+  const ASTScope *getActiveContinuation() const;
+
+  /// Retrieve the historical continuation (which might also be active).
+  ///
+  /// This is the oldest historical continuation, so a \c SourceFile
+  /// continuation will be returned even if it's been replaced by a more local
+  /// continuation.
+  const ASTScope *getHistoricalContinuation() const;
+
+  /// Set the active continuation.
+  void addActiveContinuation(const ASTScope *newContinuation) const;
+
+  /// Remove the active continuation.
+  void removeActiveContinuation() const;
+
+  /// Clear out the continuation, because it has been stolen been transferred to
+  /// a child node.
+  void clearActiveContinuation() const;
+
   /// Constructor that only initializes the kind and parent, leaving the
   /// pieces to be initialized by the caller.
   ASTScope(ASTScopeKind kind, const ASTScope *parent)
@@ -300,6 +348,16 @@ class ASTScope {
   /// Constructor that initializes a preexpanded node.
   ASTScope(const ASTScope *parent, ArrayRef<ASTScope *> children);
 
+  ASTScope(const ASTScope *parent, TypeDecl *typeDecl)
+      : ASTScope(ASTScopeKind::TypeDecl, parent) {
+    this->typeDecl = typeDecl;
+  }
+
+  ASTScope(const ASTScope *parent, ExtensionDecl *extension)
+      : ASTScope(ASTScopeKind::ExtensionGenericParams, parent) {
+    this->extension = extension;
+  }
+
   ASTScope(const ASTScope *parent, IterableDeclContext *idc)
       : ASTScope(ASTScopeKind::TypeOrExtensionBody, parent) {
     this->iterableDeclContext = idc;
@@ -313,8 +371,11 @@ class ASTScope {
     this->genericParams.index = index;
   }
 
-  ASTScope(const ASTScope *parent, AbstractFunctionDecl *abstractFunction)
-      : ASTScope(ASTScopeKind::AbstractFunctionDecl, parent) {
+  ASTScope(ASTScopeKind kind, const ASTScope *parent,
+           AbstractFunctionDecl *abstractFunction)
+      : ASTScope(kind, parent) {
+    assert(kind == ASTScopeKind::AbstractFunctionDecl ||
+           kind == ASTScopeKind::AbstractFunctionBody);
     this->abstractFunction = abstractFunction;
   }
 
@@ -429,7 +490,8 @@ class ASTScope {
   /// Expand the children of this AST scope so they can be queried.
   void expand() const;
 
-  /// Determine whether the given scope has already been expanded.
+  /// Determine whether the given scope has already been completely expanded,
+  /// and cannot create any new children.
   bool isExpanded() const;
 
   /// Create a new AST scope if one is needed for the given declaration.
@@ -456,25 +518,28 @@ class ASTScope {
   /// introduced by this AST node.
   static ASTScope *createIfNeeded(const ASTScope *parent, ASTNode node);
 
-  /// Determine whether this is a scope from which we can perform a
-  /// continuation.
-  bool isContinuationScope() const;
+  /// Determine whether this scope can steal a continuation from its parent,
+  /// because (e.g.) it introduces some name binding that should be visible
+  /// in the continuation.
+  bool canStealContinuation() const;
 
-  /// Enumerate the continuation scopes for the given parent,
+  /// Enumerate the continuation child scopes for the given scope.
   ///
-  /// Statements, such as 'guard' and local declarations, introduce scopes
-  /// that extend to the end of an enclosing brace-stmt. This
-  /// operation finds each of the "continuation" scopes in the nearest
-  /// enclosing brace statement.
+  /// \param addChild Function that will be invoked to add the continuation
+  /// child. This function should return true if the child steals the
+  /// continuation, which terminates the enumeration.
   void enumerateContinuationScopes(
-         llvm::function_ref<void(ASTScope *)> fn) const;
+         llvm::function_ref<bool(ASTScope *)> addChild) const;
 
   /// Compute the source range of this scope.
   SourceRange getSourceRangeImpl() const;
 
   /// Retrieve the ASTContext in which this scope exists.
   ASTContext &getASTContext() const;
 
+  /// Retrieve the source file scope, which is the root of the tree.
+  const ASTScope *getSourceFileScope() const;
+
   /// Retrieve the source file in which this scope exists.
   SourceFile &getSourceFile() const;
 
@@ -497,24 +562,29 @@ class ASTScope {
 
   /// Determine the source range covered by this scope.
   SourceRange getSourceRange() const {
-    if (CachedSourceRange.isInvalid() ||
-        getKind() == ASTScopeKind::SourceFile) {
-      CachedSourceRange = getSourceRangeImpl();
+    SourceRange range = getSourceRangeImpl();
+
+    // If there was ever a continuation, use it's end range.
+    if (auto historical = getHistoricalContinuation()) {
+      if (historical != this)
+        range.End = historical->getSourceRange().End;
     }
-    return CachedSourceRange;
+
+    return range;
   }
 
-  /// Retrieve the local declatation when
-  /// \c getKind() == ASTScopeKind::LocalDeclaration.
-  Decl *getLocalDeclaration() const {
-    assert(getKind() == ASTScopeKind::LocalDeclaration);
-    return localDeclaration;
+  /// Retrieve the type declaration when \c getKind() == ASTScopeKind::TypeDecl.
+  TypeDecl *getTypeDecl() const {
+    assert(getKind() == ASTScopeKind::TypeDecl);
+    return typeDecl;
   }
 
   /// Retrieve the abstract function declaration when
-  /// \c getKind() == ASTScopeKind::AbstractFunctionDecl;
+  /// \c getKind() == ASTScopeKind::AbstractFunctionDecl or
+  /// \c getKind() == ASTScopeKind::AbstractFunctionBody;
   AbstractFunctionDecl *getAbstractFunctionDecl() const {
-    assert(getKind() == ASTScopeKind::AbstractFunctionDecl);
+    assert(getKind() == ASTScopeKind::AbstractFunctionDecl ||
+           getKind() == ASTScopeKind::AbstractFunctionBody);
     return abstractFunction;
   }
 
@@ -543,6 +613,18 @@ class ASTScope {
   /// \seealso getDeclContext().
   DeclContext *getInnermostEnclosingDeclContext() const;
 
+  /// Retrueve the declarations whose names are directly bound by this scope.
+  ///
+  /// The declarations bound in this scope aren't available in the immediate
+  /// parent of this scope, but will still be visible in child scopes (unless
+  /// shadowed there).
+  ///
+  /// Note that this routine does not produce bindings for anything that can
+  /// be found via qualified name lookup in a \c DeclContext, such as nominal
+  /// type declarations or extensions thereof, or the source file itself. The
+  /// client can perform such lookups using the result of \c getDeclContext().
+  SmallVector<ValueDecl *, 4> getLocalBindings() const;
+
   /// Expand the entire scope map.
   ///
   /// Normally, the scope map will be expanded only as needed by its queries,