Merge branch 'master' of github.com:swiftwasm/swift into maxd/master-merge

# Conflicts:
#	test/stdlib/simd.swift.gyb
#	test/stdlib/simd_diagnostics.swift

Author: MaxDesiatov

include/swift/AST/Attr.h

@@ -36,7 +36,6 @@
 #include "swift/AST/PlatformKind.h"
 #include "swift/AST/Requirement.h"
 #include "swift/AST/TrailingCallArguments.h"
-#include "swift/AST/TypeLoc.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ErrorHandling.h"
@@ -56,6 +55,7 @@ class LazyConformanceLoader;
 class LazyMemberLoader;
 class PatternBindingInitializer;
 class TrailingWhereClause;
+class TypeExpr;
 
 /// TypeAttributes - These are attributes that may be applied to types.
 class TypeAttributes {
@@ -1110,47 +1110,41 @@ class DynamicReplacementAttr final
 
 /// The \c @_typeEraser(TypeEraserType) attribute.
 class TypeEraserAttr final : public DeclAttribute {
-  TypeLoc TypeEraserLoc;
+  TypeExpr *TypeEraserExpr;
   LazyMemberLoader *Resolver;
   uint64_t ResolverContextData;
 
   friend class ResolveTypeEraserTypeRequest;
 
-  TypeEraserAttr(SourceLoc atLoc, SourceRange range, TypeLoc typeEraserLoc,
+  TypeEraserAttr(SourceLoc atLoc, SourceRange range, TypeExpr *typeEraserExpr,
                  LazyMemberLoader *Resolver, uint64_t Data)
       : DeclAttribute(DAK_TypeEraser, atLoc, range, /*Implicit=*/false),
-        TypeEraserLoc(typeEraserLoc),
+        TypeEraserExpr(typeEraserExpr),
         Resolver(Resolver), ResolverContextData(Data) {}
 
 public:
   static TypeEraserAttr *create(ASTContext &ctx,
                                 SourceLoc atLoc, SourceRange range,
-                                TypeLoc typeEraserLoc);
+                                TypeExpr *typeEraserRepr);
 
   static TypeEraserAttr *create(ASTContext &ctx,
                                 LazyMemberLoader *Resolver,
                                 uint64_t Data);
 
   /// Retrieve the parsed type repr for this attribute, if it
   /// was parsed. Else returns \c nullptr.
-  TypeRepr *getParsedTypeEraserTypeRepr() const {
-    return TypeEraserLoc.getTypeRepr();
-  }
+  TypeRepr *getParsedTypeEraserTypeRepr() const;
 
   /// Retrieve the parsed location for this attribute, if it was parsed.
-  SourceLoc getLoc() const {
-    return TypeEraserLoc.getLoc();
-  }
+  SourceLoc getLoc() const;
 
   /// Retrieve the resolved type of this attribute if it has been resolved by a
   /// successful call to \c getResolvedType(). Otherwise,
   /// returns \c Type()
   ///
   /// This entrypoint is only suitable for syntactic clients like the
   /// AST printer. Semantic clients should use \c getResolvedType() instead.
-  Type getTypeWithoutResolving() const {
-    return TypeEraserLoc.getType();
-  }
+  Type getTypeWithoutResolving() const;
 
   /// Returns \c true if the type eraser type has a valid implementation of the
   /// erasing initializer for the given protocol.
@@ -1464,25 +1458,26 @@ class SpecializeAttr : public DeclAttribute {
 /// The @_implements attribute, which treats a decl as the implementation for
 /// some named protocol requirement (but otherwise not-visible by that name).
 class ImplementsAttr : public DeclAttribute {
-
-  TypeLoc ProtocolType;
+  TypeExpr *ProtocolType;
   DeclName MemberName;
   DeclNameLoc MemberNameLoc;
 
 public:
   ImplementsAttr(SourceLoc atLoc, SourceRange Range,
-                 TypeLoc ProtocolType,
+                 TypeExpr *ProtocolType,
                  DeclName MemberName,
                  DeclNameLoc MemberNameLoc);
 
   static ImplementsAttr *create(ASTContext &Ctx, SourceLoc atLoc,
                                 SourceRange Range,
-                                TypeLoc ProtocolType,
+                                TypeExpr *ProtocolType,
                                 DeclName MemberName,
                                 DeclNameLoc MemberNameLoc);
 
-  TypeLoc getProtocolType() const;
-  TypeLoc &getProtocolType();
+  void setProtocolType(Type ty);
+  Type getProtocolType() const;
+  TypeRepr *getProtocolTypeRepr() const;
+
   DeclName getMemberName() const { return MemberName; }
   DeclNameLoc getMemberNameLoc() const { return MemberNameLoc; }
 
@@ -1595,27 +1590,27 @@ class ClangImporterSynthesizedTypeAttr : public DeclAttribute {
 /// Defines a custom attribute.
 class CustomAttr final : public DeclAttribute,
                          public TrailingCallArguments<CustomAttr> {
-  TypeLoc type;
+  TypeExpr *typeExpr;
   Expr *arg;
   PatternBindingInitializer *initContext;
   Expr *semanticInit = nullptr;
 
   unsigned hasArgLabelLocs : 1;
   unsigned numArgLabels : 16;
 
-  CustomAttr(SourceLoc atLoc, SourceRange range, TypeLoc type,
+  CustomAttr(SourceLoc atLoc, SourceRange range, TypeExpr *type,
              PatternBindingInitializer *initContext, Expr *arg,
              ArrayRef<Identifier> argLabels, ArrayRef<SourceLoc> argLabelLocs,
              bool implicit);
 
 public:
-  static CustomAttr *create(ASTContext &ctx, SourceLoc atLoc, TypeLoc type,
+  static CustomAttr *create(ASTContext &ctx, SourceLoc atLoc, TypeExpr *type,
                             bool implicit = false) {
     return create(ctx, atLoc, type, false, nullptr, SourceLoc(), { }, { }, { },
                   SourceLoc(), implicit);
   }
 
-  static CustomAttr *create(ASTContext &ctx, SourceLoc atLoc, TypeLoc type,
+  static CustomAttr *create(ASTContext &ctx, SourceLoc atLoc, TypeExpr *type,
                             bool hasInitializer,
                             PatternBindingInitializer *initContext,
                             SourceLoc lParenLoc,
@@ -1628,8 +1623,8 @@ class CustomAttr final : public DeclAttribute,
   unsigned getNumArguments() const { return numArgLabels; }
   bool hasArgumentLabelLocs() const { return hasArgLabelLocs; }
 
-  TypeLoc &getTypeLoc() { return type; }
-  const TypeLoc &getTypeLoc() const { return type; }
+  TypeRepr *getTypeRepr() const;
+  Type getType() const;
 
   Expr *getArg() const { return arg; }
   void setArg(Expr *newArg) { arg = newArg; }
@@ -1642,6 +1637,14 @@ class CustomAttr final : public DeclAttribute,
   static bool classof(const DeclAttribute *DA) {
     return DA->getKind() == DAK_Custom;
   }
+
+private:
+  friend class CustomAttrNominalRequest;
+  void resetTypeInformation(TypeExpr *repr);
+
+private:
+  friend class CustomAttrTypeRequest;
+  void setType(Type ty);
 };
 
 /// Relates a property to its projection value property, as described by a property wrapper. For

include/swift/AST/EvaluatorDependencies.h

@@ -109,6 +109,14 @@ using DependencySource = llvm::PointerIntPair<SourceFile *, 1, DependencyScope>;
 
 struct DependencyRecorder;
 
+/// A \c DependencyCollector defines an abstract write-only buffer of
+/// \c Reference objects. References are added to a collector during the write
+/// phase of request evaluation (in \c writeDependencySink) with the various
+/// \c add* functions below..
+///
+/// A \c DependencyCollector cannot be created directly. You must invoke
+/// \c DependencyRecorder::record, which will wire a dependency collector into
+/// the provided continuation block.
 struct DependencyCollector {
   friend DependencyRecorder;
 
@@ -227,11 +235,15 @@ struct DependencyCollector {
   void addDynamicLookupName(DeclBaseName name);
 
 public:
+  /// Retrieves the dependency recorder that created this dependency collector.
   const DependencyRecorder &getRecorder() const { return parent; }
+
+  /// Returns \c true if this collector has not accumulated
+  /// any \c Reference objects.
   bool empty() const { return scratch.empty(); }
 };
 
-/// A \c DependencyCollector is an aggregator of named references discovered in a
+/// A \c DependencyRecorder is an aggregator of named references discovered in a
 /// particular \c DependencyScope during the course of request evaluation.
 struct DependencyRecorder {
   friend DependencyCollector;
@@ -266,22 +278,62 @@ struct DependencyRecorder {
   explicit DependencyRecorder(Mode mode) : mode{mode}, isRecording{false} {};
 
 private:
+  /// Records the given \c Reference as a dependency of the current dependency
+  /// source.
+  ///
+  /// This is as opposed to merely collecting a \c Reference, which may just buffer
+  /// it for realization or replay later.
   void realize(const DependencyCollector::Reference &ref);
 
 public:
-  void replay(const llvm::SetVector<swift::ActiveRequest> &stack,
-              const swift::ActiveRequest &req);
+  /// Begins the recording of references by invoking the given continuation
+  /// with a fresh \c DependencyCollector object. This object should be used
+  /// to buffer dependency-relevant references to names looked up by a
+  /// given request.
+  ///
+  /// Recording only occurs for requests that are dependency sinks.
   void record(const llvm::SetVector<swift::ActiveRequest> &stack,
               llvm::function_ref<void(DependencyCollector &)> rec);
 
+  /// Replays the \c Reference objects collected by a given cached request and
+  /// its sub-requests into the current dependency scope.
+  ///
+  /// Dependency replay ensures that cached requests do not "hide" names from
+  /// the active dependency scope. This would otherwise occur frequently in
+  /// batch mode, where cached requests effectively block the re-evaluation of
+  /// a large quantity of computations that perform name lookups by design.
+  ///
+  /// Replay need only occur for requests that are (separately) cached.
+  void replay(const llvm::SetVector<swift::ActiveRequest> &stack,
+              const swift::ActiveRequest &req);
 private:
+  /// Given the current stack of requests and a buffer of \c Reference objects
+  /// walk the active stack looking for the next-innermost cached request. If
+  /// found, insert the buffer of references into that request's known reference
+  /// set.
+  ///
+  /// This algorithm ensures that references propagate lazily up the request
+  /// graph from cached sub-requests to their cached parents. Once this process
+  /// completes, all cached requests in the request graph will see the
+  /// union of all references recorded while evaluating their sub-requests.
+  ///
+  /// This algorithm *must* be tail-called during
+  /// \c DependencyRecorder::record or \c DependencyRecorder::replay
+  /// or the corresponding set of references for the active dependency scope
+  /// will become incoherent.
   void
   unionNearestCachedRequest(ArrayRef<swift::ActiveRequest> stack,
                             const DependencyCollector::ReferenceSet &scratch);
 
 public:
   using ReferenceEnumerator =
       llvm::function_ref<void(const DependencyCollector::Reference &)>;
+
+  /// Enumerates the set of references associated with a given source file,
+  /// passing them to the given enumeration callback.
+  ///
+  /// The order of enumeration is completely undefined. It is the responsibility
+  /// of callers to ensure they are order-invariant or are sorting the result.
   void enumerateReferencesInFile(const SourceFile *SF,
                                  ReferenceEnumerator f) const ;
 

include/swift/AST/Expr.h

@@ -597,13 +597,23 @@ class ErrorExpr : public Expr {
 /// CodeCompletionExpr - Represents the code completion token in the AST, this
 /// can help us preserve the context of the code completion position.
 class CodeCompletionExpr : public Expr {
-  SourceRange Range;
+  Expr *Base;
+  SourceLoc Loc;
 
 public:
-  CodeCompletionExpr(SourceRange Range, Type Ty = Type())
-      : Expr(ExprKind::CodeCompletion, /*Implicit=*/true, Ty), Range(Range) {}
+  CodeCompletionExpr(Expr *Base, SourceLoc Loc)
+      : Expr(ExprKind::CodeCompletion, /*Implicit=*/true, Type()),
+        Base(Base), Loc(Loc) {}
 
-  SourceRange getSourceRange() const { return Range; }
+  CodeCompletionExpr(SourceLoc Loc)
+      : CodeCompletionExpr(/*Base=*/nullptr, Loc) {}
+
+  Expr *getBase() const { return Base; }
+  void setBase(Expr *E) { Base = E; }
+
+  SourceLoc getLoc() const { return Loc; }
+  SourceLoc getStartLoc() const { return Base ? Base->getStartLoc() : Loc; }
+  SourceLoc getEndLoc() const { return Loc; }
 
   static bool classof(const Expr *E) {
     return E->getKind() == ExprKind::CodeCompletion;

include/swift/AST/FileSystem.h

@@ -15,6 +15,7 @@
 
 #include "swift/Basic/FileSystem.h"
 #include "swift/AST/DiagnosticEngine.h"
+#include "swift/AST/DiagnosticsCommon.h"
 
 namespace swift {
 

include/swift/AST/FineGrainedDependencies.h

@@ -1,4 +1,4 @@
-//===----- FineGrainedependencies.h -----------------------------*- C++ -*-===//
+//===----- FineGrainedDependencies.h ----------------------------*- C++ -*-===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -632,6 +632,11 @@ class DepGraphNode {
 
   const DependencyKey &getKey() const { return key; }
 
+  /// Only used when the driver is reading a SourceFileDepGraphNode.
+  void setKey(const DependencyKey &key) {
+    this->key = key;
+  }
+
   const Optional<StringRef> getFingerprint() const {
     if (fingerprint) {
       return StringRef(fingerprint.getValue());
@@ -684,15 +689,15 @@ class SourceFileDepGraphNode : public DepGraphNode {
   /// True iff a Decl exists for this node.
   /// If a provides and a depends in the existing system both have the same key,
   /// only one SourceFileDepGraphNode is emitted.
-  bool isProvides;
+  bool isProvides = false;
 
   friend ::llvm::yaml::MappingContextTraits<SourceFileDepGraphNode,
                                             SourceFileDepGraph>;
 
 public:
   /// When the driver imports a node create an uninitialized instance for
   /// deserializing.
-  SourceFileDepGraphNode() : DepGraphNode(), sequenceNumber(~0) {}
+  SourceFileDepGraphNode() : DepGraphNode() {}
 
   /// Used by the frontend to build nodes.
   SourceFileDepGraphNode(DependencyKey key, Optional<StringRef> fingerprint,
@@ -736,6 +741,9 @@ class SourceFileDepGraphNode : public DepGraphNode {
                                                            : "somewhere else");
   }
 
+  SWIFT_DEBUG_DUMP;
+  void dump(llvm::raw_ostream &os) const;
+
   bool verify() const {
     DepGraphNode::verify();
     assert(getIsProvides() || isDepends());
@@ -872,7 +880,6 @@ class SourceFileDepGraph {
 
   void emitDotFile(StringRef outputPath, DiagnosticEngine &diags);
 
-private:
   void addNode(SourceFileDepGraphNode *n) {
     n->setSequenceNumber(allNodes.size());
     allNodes.push_back(n);