Parser: avoid on-demand parsing when parsing interface tokens.

docs/ABI/Mangling.rst

@@ -59,6 +59,7 @@ Globals
   global ::= nominal-type 'Ml'           // in-place type initialization cache
   global ::= nominal-type 'Mm'           // class metaclass
   global ::= nominal-type 'Mn'           // nominal type descriptor
+  global ::= nominal-type 'Mu'           // class method lookup function
   global ::= module 'MXM'                // module descriptor
   global ::= context 'MXE'               // extension descriptor
   global ::= context 'MXX'               // anonymous context descriptor

include/swift/ABI/Metadata.h

@@ -787,6 +787,8 @@ struct TargetMethodDescriptor {
   // TODO: add method types or anything else needed for reflection.
 };
 
+using MethodDescriptor = TargetMethodDescriptor<InProcess>;
+
 /// Header for a class vtable descriptor. This is a variable-sized
 /// structure that describes how to find and parse a vtable
 /// within the type metadata for a class.

include/swift/AST/DiagnosticsParse.def

@@ -1295,7 +1295,11 @@ ERROR(swift_native_objc_runtime_base_must_be_identifier,none,
       "@_swift_native_objc_runtime_base class name must be an identifier", ())
 
 ERROR(attr_interpolated_string,none,
-"%0 cannot be an interpolated string literal", (StringRef))
+"'%0' cannot be an interpolated string literal", (StringRef))
+ERROR(attr_multiline_string,none,
+"'%0' cannot be a multiline string literal", (StringRef))
+ERROR(attr_extended_escaping_string,none,
+"'%0' cannot be an extended escaping string literal", (StringRef))
 
 ERROR(attr_only_at_non_local_scope, none,
       "attribute '%0' can only be used in a non-local scope", (StringRef))

include/swift/AST/Module.h

@@ -151,6 +151,45 @@ class ModuleDecl : public DeclContext, public TypeDecl {
     }
   };
 
+  /// Produces the components of a given module's full name in reverse order.
+  ///
+  /// For a Swift module, this will only ever have one component, but an
+  /// imported Clang module might actually be a submodule.
+  class ReverseFullNameIterator {
+  public:
+    // Make this look like a valid STL iterator.
+    using difference_type = int;
+    using value_type = StringRef;
+    using pointer = StringRef *;
+    using reference = StringRef;
+    using iterator_category = std::forward_iterator_tag;
+
+  private:
+    PointerUnion<const ModuleDecl *, const /* clang::Module */ void *> current;
+  public:
+    ReverseFullNameIterator() = default;
+    explicit ReverseFullNameIterator(const ModuleDecl *M);
+    explicit ReverseFullNameIterator(const clang::Module *clangModule) {
+      current = clangModule;
+    }
+
+    StringRef operator*() const;
+    ReverseFullNameIterator &operator++();
+
+    friend bool operator==(ReverseFullNameIterator left,
+                           ReverseFullNameIterator right) {
+      return left.current == right.current;
+    }
+    friend bool operator!=(ReverseFullNameIterator left,
+                           ReverseFullNameIterator right) {
+      return !(left == right);
+    }
+
+    /// This is a convenience function that writes the entire name, in forward
+    /// order, to \p out.
+    void printForward(raw_ostream &out) const;
+  };
+
 private:
   /// If non-NULL, a plug-in that should be used when performing external
   /// lookups.
@@ -490,6 +529,15 @@ class ModuleDecl : public DeclContext, public TypeDecl {
   /// Returns the associated clang module if one exists.
   const clang::Module *findUnderlyingClangModule() const;
 
+  /// Returns a generator with the components of this module's full,
+  /// hierarchical name.
+  ///
+  /// For a Swift module, this will only ever have one component, but an
+  /// imported Clang module might actually be a submodule.
+  ReverseFullNameIterator getReverseFullModuleName() const {
+    return ReverseFullNameIterator(this);
+  }
+
   SourceRange getSourceRange() const { return SourceRange(); }
 
   static bool classof(const DeclContext *DC) {
@@ -825,7 +873,8 @@ class SourceFile final : public FileUnit {
 
   /// A hash of all interface-contributing tokens that have been lexed for
   /// this source file so far.
-  llvm::MD5 InterfaceHash;
+  /// We only collect interface hash for primary input files.
+  llvm::Optional<llvm::MD5> InterfaceHash;
 
   /// \brief The ID for the memory buffer containing this file's source.
   ///
@@ -1069,20 +1118,26 @@ class SourceFile final : public FileUnit {
   /// Set the root refinement context for the file.
   void setTypeRefinementContext(TypeRefinementContext *TRC);
 
+  void enableInterfaceHash() {
+    assert(!hasInterfaceHash());
+    InterfaceHash.emplace();
+  }
+
+  bool hasInterfaceHash() const {
+    return InterfaceHash.hasValue();
+  }
+
   void recordInterfaceToken(StringRef token) {
     assert(!token.empty());
-    InterfaceHash.update(token);
+    InterfaceHash->update(token);
     // Add null byte to separate tokens.
     uint8_t a[1] = {0};
-    InterfaceHash.update(a);
+    InterfaceHash->update(a);
   }
 
-  const llvm::MD5 &getInterfaceHashState() { return InterfaceHash; }
-  void setInterfaceHashState(const llvm::MD5 &state) { InterfaceHash = state; }
-
   void getInterfaceHash(llvm::SmallString<32> &str) {
     llvm::MD5::MD5Result result;
-    InterfaceHash.final(result);
+    InterfaceHash->final(result);
     llvm::MD5::stringifyResult(result, str);
   }
 

include/swift/AST/Pattern.h

@@ -383,14 +383,25 @@ class AnyPattern : public Pattern {
 /// dynamic type match.
 class TypedPattern : public Pattern {
   Pattern *SubPattern;
-  mutable TypeLoc PatType;
+  TypeRepr *PatTypeRepr;
 
 public:
-  TypedPattern(Pattern *pattern, TypeLoc tl, Optional<bool> implicit = None)
-    : Pattern(PatternKind::Typed), SubPattern(pattern), PatType(tl) {
-    if (implicit.hasValue() ? *implicit : !tl.hasLocation())
-      setImplicit();
-    Bits.TypedPattern.IsPropagatedType = false;
+  /// Creates a new TypedPattern which annotates the provided sub-pattern with
+  /// the provided TypeRepr. If 'implicit' is true, the pattern will be
+  /// set to implicit. If false, it will not. If 'implicit' is not provided,
+  /// then the pattern will be set to 'implicit' if there is a provided TypeRepr
+  /// which has a valid SourceRange.
+  TypedPattern(Pattern *pattern, TypeRepr *tr, Optional<bool> implicit = None);
+
+  /// Creates an implicit typed pattern annotating the provided sub-pattern
+  /// with a given type.
+  static TypedPattern *
+  createImplicit(ASTContext &ctx, Pattern *pattern, Type type) {
+    auto tp = new (ctx) TypedPattern(pattern, /*typeRepr*/nullptr,
+                                     /*implicit*/true);
+    if (!type.isNull())
+      tp->setType(type);
+    return tp;
   }
 
   /// True if the type in this \c TypedPattern was propagated from a different
@@ -412,27 +423,10 @@ class TypedPattern : public Pattern {
   const Pattern *getSubPattern() const { return SubPattern; }
   void setSubPattern(Pattern *p) { SubPattern = p; }
 
-  TypeLoc &getTypeLoc() {
-    // If we have a delayed interface type, set our type from that.
-    if (getDelayedInterfaceType())
-      PatType.setType(getType());
-
-    return PatType;
-  }
-  TypeLoc getTypeLoc() const {
-    // If we have a delayed interface type, set our type from that.
-    if (getDelayedInterfaceType())
-      PatType.setType(getType());
-
-    return PatType;
-  }
-
-  SourceLoc getLoc() const {
-    if (SubPattern->isImplicit())
-      return PatType.getSourceRange().Start;
+  TypeRepr *getTypeRepr() const { return PatTypeRepr; }
 
-    return SubPattern->getLoc();
-  }
+  TypeLoc getTypeLoc() const;
+  SourceLoc getLoc() const;
   SourceRange getSourceRange() const;
 
   static bool classof(const Pattern *P) {

include/swift/Demangling/DemangleNodes.def

@@ -119,6 +119,7 @@ NODE(MergedFunction)
 NODE(Metatype)
 NODE(MetatypeRepresentation)
 NODE(Metaclass)
+NODE(MethodLookupFunction)
 CONTEXT_NODE(ModifyAccessor)
 CONTEXT_NODE(Module)
 CONTEXT_NODE(NativeOwningAddressor)

include/swift/IRGen/Linking.h

@@ -129,6 +129,9 @@ class LinkEntity {
     /// ConstructorDecl* inside a protocol or a class.
     MethodDescriptorAllocator,
 
+    /// A method lookup function for a class.  The pointer is a ClassDecl*.
+    MethodLookupFunction,
+
     /// A resilient enum tag index. The pointer is a EnumElementDecl*.
     EnumCase,
 
@@ -482,6 +485,12 @@ class LinkEntity {
     return entity;
   }
 
+  static LinkEntity forMethodLookupFunction(ClassDecl *classDecl) {
+    LinkEntity entity;
+    entity.setForDecl(Kind::MethodLookupFunction, classDecl);
+    return entity;
+  }
+
   static LinkEntity forFieldOffset(VarDecl *decl) {
     LinkEntity entity;
     entity.setForDecl(Kind::FieldOffset, decl);

include/swift/Runtime/Metadata.h

@@ -595,6 +595,15 @@ void swift_initClassMetadata(ClassMetadata *self,
                              const TypeLayout * const *fieldTypes,
                              size_t *fieldOffsets);
 
+/// Given class metadata, a class descriptor and a method descriptor, look up
+/// and load the vtable entry from the given metadata. The metadata must be of
+/// the same class or a subclass of the descriptor.
+SWIFT_RUNTIME_EXPORT
+void *
+swift_lookUpClassMethod(ClassMetadata *metadata,
+                        MethodDescriptor *method,
+                        ClassDescriptor *description);
+
 /// \brief Fetch a uniqued metadata for a metatype type.
 SWIFT_RUNTIME_EXPORT
 const MetatypeMetadata *

include/swift/Runtime/RuntimeFunctions.def

@@ -773,6 +773,17 @@ FUNCTION(InitClassMetadata,
               SizeTy->getPointerTo()),
          ATTRS(NoUnwind))
 
+// void *swift_lookUpClassMethod(Metadata *metadata,
+//                               ClassDescriptor *description,
+//                               MethodDescriptor *method);
+FUNCTION(LookUpClassMethod,
+         swift_lookUpClassMethod, C_CC,
+         RETURNS(Int8PtrTy),
+         ARGS(TypeMetadataPtrTy,
+              MethodDescriptorStructTy->getPointerTo(),
+              TypeContextDescriptorPtrTy),
+         ATTRS(NoUnwind))
+
 // void swift_initStructMetadata(Metadata *structType,
 //                               StructLayoutFlags flags,
 //                               size_t numFields,

include/swift/SIL/SILDeclRef.h

@@ -359,6 +359,11 @@ struct SILDeclRef {
   /// entry overridden by this method.
   SILDeclRef getOverriddenWitnessTableEntry() const;
 
+  /// Return the original protocol requirement that introduced the witness table
+  /// entry overridden by this method.
+  static AbstractFunctionDecl *getOverriddenWitnessTableEntry(
+                                                    AbstractFunctionDecl *func);
+
   /// True if the referenced entity is some kind of thunk.
   bool isThunk() const;
 

lib/AST/ASTWalker.cpp

@@ -1571,8 +1571,9 @@ Pattern *Traversal::visitTypedPattern(TypedPattern *P) {
   else
     return nullptr;
   if (!P->isImplicit())
-    if (doIt(P->getTypeLoc()))
-      return nullptr;
+    if (auto *TR = P->getTypeRepr())
+      if (doIt(TR))
+        return nullptr;
   return P;
 }
 

lib/AST/Module.cpp

@@ -1005,14 +1005,65 @@ bool ModuleDecl::isSameAccessPath(AccessPathTy lhs, AccessPathTy rhs) {
   });
 }
 
+ModuleDecl::ReverseFullNameIterator::ReverseFullNameIterator(
+    const ModuleDecl *M) {
+  assert(M);
+  // Note: This will look through overlays as well, but that's fine for name
+  // generation purposes. The point of an overlay is to
+  if (auto *clangModule = M->findUnderlyingClangModule())
+    current = clangModule;
+  else
+    current = M;
+}
+
+StringRef ModuleDecl::ReverseFullNameIterator::operator*() const {
+  assert(current && "all name components exhausted");
+
+  if (auto *swiftModule = current.dyn_cast<const ModuleDecl *>())
+    return swiftModule->getName().str();
+
+  auto *clangModule =
+      static_cast<const clang::Module *>(current.get<const void *>());
+  return clangModule->Name;
+}
+
+ModuleDecl::ReverseFullNameIterator &
+ModuleDecl::ReverseFullNameIterator::operator++() {
+  if (!current)
+    return *this;
+
+  if (auto *swiftModule = current.dyn_cast<const ModuleDecl *>()) {
+    current = nullptr;
+    return *this;
+  }
+
+  auto *clangModule =
+      static_cast<const clang::Module *>(current.get<const void *>());
+  if (clangModule->Parent)
+    current = clangModule->Parent;
+  else
+    current = nullptr;
+  return *this;
+}
+
+void
+ModuleDecl::ReverseFullNameIterator::printForward(raw_ostream &out) const {
+  SmallVector<StringRef, 8> elements(*this, {});
+  swift::interleave(swift::reversed(elements),
+                    [&out](StringRef next) { out << next; },
+                    [&out] { out << '.'; });
+}
+
 void
 ModuleDecl::removeDuplicateImports(SmallVectorImpl<ImportedModule> &imports) {
   std::sort(imports.begin(), imports.end(),
             [](const ImportedModule &lhs, const ImportedModule &rhs) -> bool {
     // Arbitrarily sort by name to get a deterministic order.
-    // FIXME: Submodules don't get sorted properly here.
-    if (lhs.second != rhs.second)
-      return lhs.second->getName().str() < rhs.second->getName().str();
+    if (lhs.second != rhs.second) {
+      return std::lexicographical_compare(
+          lhs.second->getReverseFullModuleName(), {},
+          rhs.second->getReverseFullModuleName(), {});
+    }
     using AccessPathElem = std::pair<Identifier, SourceLoc>;
     return std::lexicographical_compare(lhs.first.begin(), lhs.first.end(),
                                         rhs.first.begin(), rhs.first.end(),