---

yaml
---
r: 348874
b: refs/heads/master
c: 45545c6
h: refs/heads/master

Author: compnerd

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 45d3b254adbec51301183dee9b5f2baf995762da
+refs/heads/master: 45545c6a0d52994997ed6db74e23d45364225d15
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/include/swift/AST/ASTDemangler.h

@@ -58,6 +58,9 @@ class ASTBuilder {
   using BuiltTypeDecl = swift::GenericTypeDecl *; // nominal or type alias
   using BuiltProtocolDecl = swift::ProtocolDecl *;
   explicit ASTBuilder(ASTContext &ctx) : Ctx(ctx) {}
+  
+  /// The resolver to use for type checking, if necessary.
+  LazyResolver *Resolver = nullptr;
 
   ASTContext &getASTContext() { return Ctx; }
   DeclContext *getNotionalDC();

trunk/include/swift/AST/ASTTypeIDZone.def

@@ -33,7 +33,6 @@ SWIFT_TYPEID_NAMED(InfixOperatorDecl *, InfixOperatorDecl)
 SWIFT_TYPEID_NAMED(IterableDeclContext *, IterableDeclContext)
 SWIFT_TYPEID_NAMED(ModuleDecl *, ModuleDecl)
 SWIFT_TYPEID_NAMED(NominalTypeDecl *, NominalTypeDecl)
-SWIFT_TYPEID_NAMED(OpaqueTypeDecl *, OpaqueTypeDecl)
 SWIFT_TYPEID_NAMED(OperatorDecl *, OperatorDecl)
 SWIFT_TYPEID_NAMED(Optional<PropertyWrapperMutability>,
                    PropertyWrapperMutability)

trunk/include/swift/AST/ASTTypeIDs.h

@@ -34,7 +34,6 @@ class IterableDeclContext;
 class ModuleDecl;
 class NominalTypeDecl;
 class OperatorDecl;
-class OpaqueTypeDecl;
 class PrecedenceGroupDecl;
 struct PropertyWrapperBackingPropertyInfo;
 struct PropertyWrapperTypeInfo;

trunk/include/swift/AST/Decl.h

@@ -388,7 +388,7 @@ class alignas(1 << DeclAlignInBits) Decl {
   SWIFT_INLINE_BITFIELD(SubscriptDecl, VarDecl, 2,
     StaticSpelling : 2
   );
-  SWIFT_INLINE_BITFIELD(AbstractFunctionDecl, ValueDecl, 3+8+1+1+1+1+1+1,
+  SWIFT_INLINE_BITFIELD(AbstractFunctionDecl, ValueDecl, 3+8+1+1+1+1+1+1+1+1,
     /// \see AbstractFunctionDecl::BodyKind
     BodyKind : 3,
 
@@ -404,6 +404,12 @@ class alignas(1 << DeclAlignInBits) Decl {
     /// Whether the function body throws.
     Throws : 1,
 
+    /// Whether this function requires a new vtable entry.
+    NeedsNewVTableEntry : 1,
+
+    /// Whether NeedsNewVTableEntry is valid.
+    HasComputedNeedsNewVTableEntry : 1,
+
     /// Whether this member was synthesized as part of a derived
     /// protocol conformance.
     Synthesized : 1,
@@ -412,10 +418,7 @@ class alignas(1 << DeclAlignInBits) Decl {
     HasSingleExpressionBody : 1
   );
 
-  SWIFT_INLINE_BITFIELD(FuncDecl, AbstractFunctionDecl, 1+1+2+1+1+2,
-    /// Whether we've computed the 'static' flag yet.
-    IsStaticComputed : 1,
-
+  SWIFT_INLINE_BITFIELD(FuncDecl, AbstractFunctionDecl, 1+2+1+1+2,
     /// Whether this function is a 'static' method.
     IsStatic : 1,
 
@@ -851,6 +854,17 @@ class alignas(1 << DeclAlignInBits) Decl {
     return getValidationState() > ValidationState::Unchecked;
   }
 
+  /// Manually indicate that validation is complete for the declaration. For
+  /// example: during importing, code synthesis, or derived conformances.
+  ///
+  /// For normal code validation, please use DeclValidationRAII instead.
+  ///
+  /// FIXME -- Everything should use DeclValidationRAII instead of this.
+  void setValidationToChecked() {
+    if (!isBeingValidated())
+      Bits.Decl.ValidationState = unsigned(ValidationState::Checked);
+  }
+
   bool escapedFromIfConfig() const {
     return Bits.Decl.EscapedFromIfConfig;
   }
@@ -2591,9 +2605,6 @@ class ValueDecl : public Decl {
   /// if the base declaration is \c open, the override might have to be too.
   bool hasOpenAccess(const DeclContext *useDC) const;
 
-  /// FIXME: This is deprecated.
-  bool isRecursiveValidation() const;
-
   /// Retrieve the "interface" type of this value, which uses
   /// GenericTypeParamType if the declaration is generic. For a generic
   /// function, this will have a GenericFunctionType with a
@@ -2753,6 +2764,12 @@ class ValueDecl : public Decl {
   /// Get the representative for this value's opaque result type, if it has one.
   OpaqueReturnTypeRepr *getOpaqueResultTypeRepr() const;
 
+  /// Set the opaque return type decl for this decl.
+  ///
+  /// `this` must be of a decl type that supports opaque return types, and
+  /// must not have previously had an opaque result type set.
+  void setOpaqueResultTypeDecl(OpaqueTypeDecl *D);
+
   /// Retrieve the attribute associating this declaration with a
   /// function builder, if there is one.
   CustomAttr *getAttachedFunctionBuilder() const;
@@ -4513,6 +4530,8 @@ class AbstractStorageDecl : public ValueDecl {
     Bits.AbstractStorageDecl.IsStatic = IsStatic;
   }
 
+  OpaqueTypeDecl *OpaqueReturn = nullptr;
+
 public:
 
   /// Should this declaration be treated as if annotated with transparent
@@ -4770,6 +4789,14 @@ class AbstractStorageDecl : public ValueDecl {
 
   bool hasAnyDynamicReplacementAccessors() const;
 
+  OpaqueTypeDecl *getOpaqueResultTypeDecl() const {
+    return OpaqueReturn;
+  }
+  void setOpaqueResultTypeDecl(OpaqueTypeDecl *decl) {
+    assert(!OpaqueReturn && "already has opaque type decl");
+    OpaqueReturn = decl;
+  }
+
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) {
     return D->getKind() >= DeclKind::First_AbstractStorageDecl &&
@@ -5547,8 +5574,6 @@ class ImportAsMemberStatus {
 
 /// Base class for function-like declarations.
 class AbstractFunctionDecl : public GenericContext, public ValueDecl {
-  friend class NeedsNewVTableEntryRequest;
-
 public:
   enum class BodyKind {
     /// The function did not have a body in the source code file.
@@ -5618,11 +5643,6 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// Location of the 'throws' token.
   SourceLoc ThrowsLoc;
 
-  struct {
-    unsigned NeedsNewVTableEntryComputed : 1;
-    unsigned NeedsNewVTableEntry : 1;
-  } LazySemanticInfo = { };
-
   AbstractFunctionDecl(DeclKind Kind, DeclContext *Parent, DeclName Name,
                        SourceLoc NameLoc, bool Throws, SourceLoc ThrowsLoc,
                        bool HasImplicitSelfDecl,
@@ -5634,6 +5654,8 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
     Bits.AbstractFunctionDecl.HasImplicitSelfDecl = HasImplicitSelfDecl;
     Bits.AbstractFunctionDecl.Overridden = false;
     Bits.AbstractFunctionDecl.Throws = Throws;
+    Bits.AbstractFunctionDecl.NeedsNewVTableEntry = false;
+    Bits.AbstractFunctionDecl.HasComputedNeedsNewVTableEntry = false;
     Bits.AbstractFunctionDecl.Synthesized = false;
     Bits.AbstractFunctionDecl.HasSingleExpressionBody = false;
   }
@@ -5803,9 +5825,16 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
     return getBodyKind() == BodyKind::MemberwiseInitializer;
   }
 
-  /// For a method of a class, checks whether it will require a new entry in the
-  /// vtable.
-  bool needsNewVTableEntry() const;
+  void setNeedsNewVTableEntry(bool value) {
+    Bits.AbstractFunctionDecl.HasComputedNeedsNewVTableEntry = true;
+    Bits.AbstractFunctionDecl.NeedsNewVTableEntry = value;
+  }
+
+  bool needsNewVTableEntry() const {
+    if (!Bits.AbstractFunctionDecl.HasComputedNeedsNewVTableEntry)
+      const_cast<AbstractFunctionDecl *>(this)->computeNeedsNewVTableEntry();
+    return Bits.AbstractFunctionDecl.NeedsNewVTableEntry;
+  }
 
   bool isEffectiveLinkageMoreVisibleThan(ValueDecl *other) const {
     return (std::min(getEffectiveAccess(), AccessLevel::Public) >
@@ -5947,13 +5976,14 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, SelfAccessKind SAK);
 class FuncDecl : public AbstractFunctionDecl {
   friend class AbstractFunctionDecl;
   friend class SelfAccessKindRequest;
-  friend class IsStaticRequest;
 
   SourceLoc StaticLoc;  // Location of the 'static' token or invalid.
   SourceLoc FuncLoc;    // Location of the 'func' token.
 
   TypeLoc FnRetType;
 
+  OpaqueTypeDecl *OpaqueReturn = nullptr;
+
 protected:
   FuncDecl(DeclKind Kind,
            SourceLoc StaticLoc, StaticSpellingKind StaticSpelling,
@@ -5969,14 +5999,14 @@ class FuncDecl : public AbstractFunctionDecl {
       StaticLoc(StaticLoc), FuncLoc(FuncLoc) {
     assert(!Name.getBaseName().isSpecial());
 
+    Bits.FuncDecl.IsStatic =
+      StaticLoc.isValid() || StaticSpelling != StaticSpellingKind::None;
     Bits.FuncDecl.StaticSpelling = static_cast<unsigned>(StaticSpelling);
 
     Bits.FuncDecl.ForcedStaticDispatch = false;
     Bits.FuncDecl.SelfAccess =
       static_cast<unsigned>(SelfAccessKind::NonMutating);
     Bits.FuncDecl.SelfAccessComputed = false;
-    Bits.FuncDecl.IsStaticComputed = false;
-    Bits.FuncDecl.IsStatic = false;
   }
 
 private:
@@ -5996,13 +6026,6 @@ class FuncDecl : public AbstractFunctionDecl {
     return None;
   }
 
-  Optional<bool> getCachedIsStatic() const {
-    if (Bits.FuncDecl.IsStaticComputed)
-      return Bits.FuncDecl.IsStatic;
-
-    return None;
-  }
-
 public:
   /// Factory function only for use by deserialization.
   static FuncDecl *createDeserialized(ASTContext &Context, SourceLoc StaticLoc,
@@ -6025,16 +6048,16 @@ class FuncDecl : public AbstractFunctionDecl {
 
   Identifier getName() const { return getFullName().getBaseIdentifier(); }
 
-  bool isStatic() const;
-
+  bool isStatic() const {
+    return Bits.FuncDecl.IsStatic;
+  }
   /// \returns the way 'static'/'class' was spelled in the source.
   StaticSpellingKind getStaticSpelling() const {
     return static_cast<StaticSpellingKind>(Bits.FuncDecl.StaticSpelling);
   }
   /// \returns the way 'static'/'class' should be spelled for this declaration.
   StaticSpellingKind getCorrectStaticSpelling() const;
   void setStatic(bool IsStatic = true) {
-    Bits.FuncDecl.IsStaticComputed = true;
     Bits.FuncDecl.IsStatic = IsStatic;
   }
 
@@ -6106,7 +6129,15 @@ class FuncDecl : public AbstractFunctionDecl {
   }
 
   OperatorDecl *getOperatorDecl() const;
-
+  
+  OpaqueTypeDecl *getOpaqueResultTypeDecl() const {
+    return OpaqueReturn;
+  }
+  void setOpaqueResultTypeDecl(OpaqueTypeDecl *decl) {
+    assert(!OpaqueReturn && "already has opaque type decl");
+    OpaqueReturn = decl;
+  }
+  
   /// Returns true if the function is forced to be statically dispatched.
   bool hasForcedStaticDispatch() const {
     return Bits.FuncDecl.ForcedStaticDispatch;

trunk/include/swift/AST/DiagnosticsSema.def

@@ -381,7 +381,7 @@ ERROR(cannot_convert_argument_value,none,
       (Type,Type))
 
 NOTE(candidate_has_invalid_argument_at_position,none,
-     "candidate expects value of type %0 for parameter #%1",
+     "candidate expects value of type %0 at position #%1",
      (Type, unsigned))
 
 ERROR(cannot_convert_array_to_variadic,none,

trunk/include/swift/AST/FileUnit.h

@@ -60,7 +60,8 @@ class FileUnit : public DeclContext {
 
   /// Look up an opaque return type by the mangled name of the declaration
   /// that defines it.
-  virtual OpaqueTypeDecl *lookupOpaqueResultType(StringRef MangledName) {
+  virtual OpaqueTypeDecl *lookupOpaqueResultType(StringRef MangledName,
+                                                 LazyResolver *resolver) {
     return nullptr;
   }
 

trunk/include/swift/AST/Module.h

@@ -354,7 +354,8 @@ class ModuleDecl : public DeclContext, public TypeDecl {
 
   /// Look up an opaque return type by the mangled name of the declaration
   /// that defines it.
-  OpaqueTypeDecl *lookupOpaqueResultType(StringRef MangledName);
+  OpaqueTypeDecl *lookupOpaqueResultType(StringRef MangledName,
+                                         LazyResolver *resolver);
 
   /// Find ValueDecls in the module and pass them to the given consumer object.
   ///

trunk/include/swift/AST/SourceFile.h

@@ -117,13 +117,6 @@ class SourceFile final : public FileUnit {
   /// The scope map that describes this source file.
   std::unique_ptr<ASTScope> Scope;
 
-  /// The set of validated opaque return type decls in the source file.
-  llvm::SmallVector<OpaqueTypeDecl *, 4> OpaqueReturnTypes;
-  llvm::StringMap<OpaqueTypeDecl *> ValidatedOpaqueReturnTypes;
-  /// The set of parsed decls with opaque return types that have not yet
-  /// been validated.
-  llvm::SetVector<ValueDecl *> UnvalidatedDeclsWithOpaqueReturnTypes;
-
   friend ASTContext;
   friend Impl;
 public:
@@ -137,6 +130,13 @@ class SourceFile final : public FileUnit {
   /// The list of local type declarations in the source file.
   llvm::SetVector<TypeDecl *> LocalTypeDecls;
 
+  /// The set of validated opaque return type decls in the source file.
+  llvm::SmallVector<OpaqueTypeDecl *, 4> OpaqueReturnTypes;
+  llvm::StringMap<OpaqueTypeDecl *> ValidatedOpaqueReturnTypes;
+  /// The set of parsed decls with opaque return types that have not yet
+  /// been validated.
+  llvm::DenseSet<ValueDecl *> UnvalidatedDeclsWithOpaqueReturnTypes;
+
   /// 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
@@ -430,13 +430,14 @@ class SourceFile final : public FileUnit {
   void setSyntaxRoot(syntax::SourceFileSyntax &&Root);
   bool hasSyntaxRoot() const;
 
-  OpaqueTypeDecl *lookupOpaqueResultType(StringRef MangledName) override;
+  OpaqueTypeDecl *lookupOpaqueResultType(StringRef MangledName,
+                                         LazyResolver *resolver) override;
 
   void addUnvalidatedDeclWithOpaqueResultType(ValueDecl *vd) {
     UnvalidatedDeclsWithOpaqueReturnTypes.insert(vd);
   }
 
-  ArrayRef<OpaqueTypeDecl *> getOpaqueReturnTypeDecls();
+  void markDeclWithOpaqueResultTypeAsValidated(ValueDecl *vd);
 
 private: