---

yaml
---
r: 326551
b: refs/heads/tensorflow
c: 6efcff6
h: refs/heads/master
i:
  326549: 5592f02
  326547: 3ad12e4
  326543: 6b1f30f

Author: David Ungar

[refs]

@@ -816,7 +816,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-04-25-a: 22f738a831d43aff2b9c9773bcb65
 refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-05-08-a: 7d98cc16689baba5c8a3b90a9329bdcc1a12b4e9
 refs/heads/cherr42: a566ad54b073c2c56ac0a705d0a5bed9743135a5
 "refs/heads/codable_test_comment_fix": fc8f6824f7f347e1e8db55bff62db385c5728b5a
-refs/heads/tensorflow: b02b4b00efc6d98cc761671e64926a61aa338b43
+refs/heads/tensorflow: 6efcff628010ad4aeffc3d26fc451db682da8314
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-11-a: 8126fd7a652e2f70ad6d76505239e34fb2ef3e1a
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-12-a: b3fd3dd84df6717f2e2e9df58c6d7e99fed57086
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-13-a: 71135119579039dc321c5f65d870050fe36efda2

branches/tensorflow/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,9 +68,9 @@ 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;
+  virtual bool
+  isInOverlayModuleForImportedModule(const DeclContext *overlayDC,
+                                     const DeclContext *importedDC) = 0;
 
   /// Look for declarations associated with the given name.
   ///
@@ -70,7 +82,7 @@ class ClangModuleLoader : public ModuleLoader {
   /// 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,
+  virtual void lookupTypeDecl(StringRef clangName, ClangTypeKind kind,
                               llvm::function_ref<void(TypeDecl *)> receiver) {}
 
   /// Look up type a declaration synthesized by the Clang importer itself, using
@@ -82,11 +94,11 @@ class ClangModuleLoader : public ModuleLoader {
   /// 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,
+  lookupRelatedEntity(StringRef clangName, ClangTypeKind kind,
+                      StringRef relatedEntityKind,
                       llvm::function_ref<void(TypeDecl *)> receiver) {}
 };
 
 } // namespace swift
 
 #endif // LLVM_SWIFT_AST_CLANG_MODULE_LOADER_H
-

branches/tensorflow/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/tensorflow/include/swift/ClangImporter/ClangImporter.h

@@ -60,17 +60,6 @@ class TypeDecl;
 class VisibleDeclConsumer;
 enum class SelectorSplitKind;
 
-/// 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 that imports Clang modules into Swift, mapping directly
 /// from Clang ASTs over to Swift ASTs.
 class ClangImporter final : public ClangModuleLoader {
@@ -168,8 +157,8 @@ class ClangImporter final : public ClangModuleLoader {
   /// 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) override;
 
   /// 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,7 +169,8 @@ 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,
+  lookupRelatedEntity(StringRef clangName, ClangTypeKind kind,
+                      StringRef relatedEntityKind,
                       llvm::function_ref<void(TypeDecl *)> receiver) override;
 
   /// Look for textually included declarations from the bridging header.

branches/tensorflow/include/swift/DWARFImporter/DWARFImporter.h

@@ -19,7 +19,6 @@
 
 #include "swift/AST/ClangModuleLoader.h"
 #include "swift/AST/Module.h"
-#include "swift/Demangling/Demangle.h"
 
 namespace llvm {
 }
@@ -43,8 +42,7 @@ class DWARFImporterDelegate {
   virtual ~DWARFImporterDelegate() = default;
   /// 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<Demangle::Node::Kind> kind,
+  virtual void lookupValue(StringRef name, llvm::Optional<ClangTypeKind> kind,
                            SmallVectorImpl<clang::Decl *> &results) {}
 };
 
@@ -111,7 +109,7 @@ class DWARFImporter final : public ClangModuleLoader {
                    NLKind lookupKind, SmallVectorImpl<ValueDecl *> &results);
   /// Perform a qualified lookup of a Clang type with this name and only return
   /// results with the specified type kind.
-  void lookupTypeDecl(StringRef rawName, Demangle::Node::Kind kind,
+  void lookupTypeDecl(StringRef rawName, ClangTypeKind kind,
                       llvm::function_ref<void(TypeDecl *)> receiver) override;
   bool
   isInOverlayModuleForImportedModule(const DeclContext *overlayDC,

branches/tensorflow/lib/AST/ASTDemangler.cpp

@@ -32,6 +32,7 @@
 #include "swift/AST/Types.h"
 #include "swift/Demangling/Demangler.h"
 #include "swift/Demangling/ManglingMacros.h"
+#include "llvm/ADT/StringSwitch.h"
 
 using namespace swift;
 
@@ -838,22 +839,45 @@ CanGenericSignature ASTBuilder::demangleGenericSignature(
       break;
     }
     case Demangle::Node::Kind::DependentGenericLayoutRequirement: {
-      // FIXME: Other layout constraints
-      LayoutConstraint constraint;
       auto kindChild = child->getChild(1);
       if (kindChild->getKind() != Demangle::Node::Kind::Identifier)
         return CanGenericSignature();
 
-      if (kindChild->getText() == "C") {
-        auto kind = LayoutConstraintKind::Class;
-        auto layout = LayoutConstraint::getLayoutConstraint(kind, Ctx);
-        builder.addRequirement(
-            Requirement(RequirementKind::Layout, subjectType, layout),
-            source, nullptr);
-        break;
+      auto kind = llvm::StringSwitch<Optional<
+          LayoutConstraintKind>>(kindChild->getText())
+        .Case("U", LayoutConstraintKind::UnknownLayout)
+        .Case("R", LayoutConstraintKind::RefCountedObject)
+        .Case("N", LayoutConstraintKind::NativeRefCountedObject)
+        .Case("C", LayoutConstraintKind::Class)
+        .Case("D", LayoutConstraintKind::NativeClass)
+        .Case("T", LayoutConstraintKind::Trivial)
+        .Cases("E", "e", LayoutConstraintKind::TrivialOfExactSize)
+        .Cases("M", "m", LayoutConstraintKind::TrivialOfAtMostSize)
+        .Default(None);
+
+      if (!kind)
+        return CanGenericSignature();
+
+      LayoutConstraint layout;
+
+      if (kind != LayoutConstraintKind::TrivialOfExactSize &&
+          kind != LayoutConstraintKind::TrivialOfAtMostSize) {
+        layout = LayoutConstraint::getLayoutConstraint(*kind, Ctx);
+      } else {
+        auto size = child->getChild(2)->getIndex();
+        auto alignment = 0;
+
+        if (child->getNumChildren() == 4)
+          alignment = child->getChild(3)->getIndex();
+
+        layout = LayoutConstraint::getLayoutConstraint(*kind, size, alignment,
+                                                       Ctx);
       }
 
-      return CanGenericSignature();
+      builder.addRequirement(
+          Requirement(RequirementKind::Layout, subjectType, layout),
+          source, nullptr);
+      break;
     }
     default:
       return CanGenericSignature();
@@ -1023,6 +1047,23 @@ ASTBuilder::findTypeDecl(DeclContext *dc,
   return result;
 }
 
+static Optional<ClangTypeKind>
+getClangTypeKindForNodeKind(Demangle::Node::Kind kind) {
+  switch (kind) {
+  case Demangle::Node::Kind::Protocol:
+    return ClangTypeKind::ObjCProtocol;
+  case Demangle::Node::Kind::Class:
+    return ClangTypeKind::ObjCClass;
+  case Demangle::Node::Kind::TypeAlias:
+    return ClangTypeKind::Typedef;
+  case Demangle::Node::Kind::Structure:
+  case Demangle::Node::Kind::Enum:
+    return ClangTypeKind::Tag;
+  default:
+    return None;
+  }
+}
+
 GenericTypeDecl *ASTBuilder::findForeignTypeDecl(StringRef name,
                                                  StringRef relatedEntityKind,
                                                  ForeignModuleKind foreignKind,
@@ -1060,23 +1101,28 @@ GenericTypeDecl *ASTBuilder::findForeignTypeDecl(StringRef name,
     consumer.foundDecl(found, DeclVisibilityKind::VisibleAtTopLevel);
   };
 
+  Optional<ClangTypeKind> lookupKind = getClangTypeKindForNodeKind(kind);
+  if (!lookupKind)
+    return nullptr;
+
   switch (foreignKind) {
   case ForeignModuleKind::SynthesizedByImporter:
     if (!relatedEntityKind.empty()) {
-      importer->lookupRelatedEntity(name, relatedEntityKind, found);
+      importer->lookupRelatedEntity(name, *lookupKind, relatedEntityKind,
+                                    found);
       break;
     }
     importer->lookupValue(Ctx.getIdentifier(name), consumer);
     if (consumer.Result)
       consumer.Result = getAcceptableTypeDeclCandidate(consumer.Result, kind);
     break;
   case ForeignModuleKind::Imported:
-    importer->lookupTypeDecl(name, kind, found);
+    importer->lookupTypeDecl(name, *lookupKind, found);
 
     // Try the DWARFImporter if it exists.
     if (!consumer.Result)
       if (auto *dwarf_importer = Ctx.getDWARFModuleLoader())
-        dwarf_importer->lookupTypeDecl(name, kind, found);
+        dwarf_importer->lookupTypeDecl(name, *lookupKind, found);
   }
 
   return consumer.Result;

branches/tensorflow/lib/ClangImporter/ClangImporter.cpp

@@ -2495,34 +2495,14 @@ void ClangImporter::lookupValue(DeclName name, VisibleDeclConsumer &consumer){
     });
 }
 
-static Optional<ClangTypeKind>
-getClangTypeKindForNodeKind(Demangle::Node::Kind kind) {
-  switch (kind) {
-  case Demangle::Node::Kind::Protocol:
-    return ClangTypeKind::ObjCProtocol;
-  case Demangle::Node::Kind::Class:
-    return ClangTypeKind::ObjCClass;
-  case Demangle::Node::Kind::TypeAlias:
-    return ClangTypeKind::Typedef;
-  case Demangle::Node::Kind::Structure:
-  case Demangle::Node::Kind::Enum:
-    return ClangTypeKind::Tag;
-  default:
-    return None;
-  }
-}
-
 void ClangImporter::lookupTypeDecl(
-    StringRef rawName, Demangle::Node::Kind kind,
+    StringRef rawName, ClangTypeKind kind,
     llvm::function_ref<void(TypeDecl *)> receiver) {
   clang::DeclarationName clangName(
       &Impl.Instance->getASTContext().Idents.get(rawName));
 
   clang::Sema::LookupNameKind lookupKind;
-  auto clang_kind = getClangTypeKindForNodeKind(kind);
-  if (!clang_kind)
-    return;
-  switch (*clang_kind) {
+  switch (kind) {
   case ClangTypeKind::Typedef:
     lookupKind = clang::Sema::LookupOrdinaryName;
     break;
@@ -2553,17 +2533,17 @@ void ClangImporter::lookupTypeDecl(
 }
 
 void ClangImporter::lookupRelatedEntity(
-    StringRef rawName, StringRef relatedEntityKind,
+    StringRef rawName, ClangTypeKind kind, StringRef relatedEntityKind,
     llvm::function_ref<void(TypeDecl *)> receiver) {
   using CISTAttr = ClangImporterSynthesizedTypeAttr;
   if (relatedEntityKind ==
         CISTAttr::manglingNameForKind(CISTAttr::Kind::NSErrorWrapper) ||
       relatedEntityKind ==
         CISTAttr::manglingNameForKind(CISTAttr::Kind::NSErrorWrapperAnon)) {
-    auto underlyingKind = Demangle::Node::Kind::Structure;
+    auto underlyingKind = ClangTypeKind::Tag;
     if (relatedEntityKind ==
           CISTAttr::manglingNameForKind(CISTAttr::Kind::NSErrorWrapperAnon)) {
-      underlyingKind = Demangle::Node::Kind::TypeAlias;
+      underlyingKind = ClangTypeKind::Typedef;
     }
     lookupTypeDecl(rawName, underlyingKind,
                    [this, receiver] (const TypeDecl *foundType) {

branches/tensorflow/lib/DWARFImporter/DWARFImporter.cpp

@@ -177,7 +177,7 @@ class DWARFImporter::Implementation {
     }
   }
 
-  void lookupTypeDecl(StringRef rawName, Demangle::Node::Kind kind,
+  void lookupTypeDecl(StringRef rawName, ClangTypeKind kind,
                       llvm::function_ref<void(TypeDecl *)> receiver) {
     SmallVector<clang::Decl *, 1> decls;
     delegate->lookupValue(rawName, kind, decls);
@@ -250,7 +250,7 @@ void DWARFImporter::lookupValue(ModuleDecl::AccessPathTy accessPath,
 }
 
 void DWARFImporter::lookupTypeDecl(
-    StringRef rawName, Demangle::Node::Kind kind,
+    StringRef rawName, ClangTypeKind kind,
     llvm::function_ref<void(TypeDecl *)> receiver) {
   Impl.lookupTypeDecl(rawName, kind, receiver);
 }

branches/tensorflow/lib/Sema/CodeSynthesis.cpp

@@ -648,20 +648,27 @@ createDesignatedInitOverride(ClassDecl *classDecl,
   // Determine the initializer parameters.
 
   // Create the initializer parameter patterns.
-  OptionSet<ParameterList::CloneFlags> options = ParameterList::Implicit;
-  options |= ParameterList::Inherited;
-  auto *bodyParams = superclassCtor->getParameters()->clone(ctx, options);
+  OptionSet<ParameterList::CloneFlags> options
+    = (ParameterList::Implicit |
+       ParameterList::Inherited |
+       ParameterList::WithoutTypes);
+  auto *superclassParams = superclassCtor->getParameters();
+  auto *bodyParams = superclassParams->clone(ctx, options);
 
   // If the superclass is generic, we need to map the superclass constructor's
   // parameter types into the generic context of our class.
   //
   // We might have to apply substitutions, if for example we have a declaration
   // like 'class A : B<Int>'.
-  for (auto *decl : *bodyParams) {
-    auto paramTy = decl->getInterfaceType();
+  for (unsigned idx : range(superclassParams->size())) {
+    auto *superclassParam = superclassParams->get(idx);
+    auto *bodyParam = bodyParams->get(idx);
+
+    auto paramTy = superclassParam->getInterfaceType();
     auto substTy = paramTy.subst(subMap, SubstFlags::UseErrorType);
-    decl->setInterfaceType(substTy);
-    decl->getTypeLoc() = TypeLoc::withoutLoc(substTy);
+
+    bodyParam->setInterfaceType(substTy);
+    bodyParam->getTypeLoc() = TypeLoc::withoutLoc(substTy);
   }
 
   // Create the initializer declaration, inheriting the name,