---

yaml
---
r: 314365
b: refs/heads/master
c: 529d784
h: refs/heads/master
i:
  314363: d6e0eb2

Author: compnerd

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 5de7c6f33eaf3abffab97be2860bf9dee78c29a2
+refs/heads/master: 529d784329b56ab620bc36bf8465d54b1b4e17c2
 refs/heads/master-next: 66a7e661ff8e88e2d4efab3e430197a7a941e352
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/include/swift/Frontend/Frontend.h

@@ -291,6 +291,12 @@ class CompilerInvocation {
 
   void setCodeCompletionFactory(CodeCompletionCallbacksFactory *Factory) {
     CodeCompletionFactory = Factory;
+    disableASTScopeLookup();
+  }
+  
+  /// Called from lldb, see rdar://53971116
+  void disableASTScopeLookup() {
+    LangOpts.EnableASTScopeLookup = false;
   }
 
   CodeCompletionCallbacksFactory *getCodeCompletionFactory() const {

trunk/include/swift/SIL/InstructionUtils.h

@@ -142,48 +142,6 @@ bool onlyUsedByAssignByWrapper(PartialApplyInst *PAI);
 void findClosuresForFunctionValue(SILValue V,
                                   TinyPtrVector<PartialApplyInst *> &results);
 
-/// A utility class for evaluating whether a newly parsed or deserialized
-/// function has qualified or unqualified ownership.
-///
-/// The reason that we are using this is that we would like to avoid needing to
-/// add code to the SILParser or to the Serializer to support this temporary
-/// staging concept of a function having qualified or unqualified
-/// ownership. Once SemanticARC is complete, SILFunctions will always have
-/// qualified ownership, so the notion of an unqualified ownership function will
-/// no longer exist.
-///
-/// Thus we note that there are three sets of instructions in SIL from an
-/// ownership perspective:
-///
-///    a. ownership qualified instructions
-///    b. ownership unqualified instructions
-///    c. instructions that do not have ownership semantics (think literals,
-///       geps, etc).
-///
-/// The set of functions can be split into ownership qualified and ownership
-/// unqualified using the rules that:
-///
-///    a. a function can never contain both ownership qualified and ownership
-///       unqualified instructions.
-///    b. a function that contains only instructions without ownership semantics
-///       is considered ownership qualified.
-///
-/// Thus we can know when parsing/serializing what category of function we have
-/// and set the bit appropriately.
-class FunctionOwnershipEvaluator {
-  NullablePtr<SILFunction> F;
-  bool HasOwnershipQualifiedInstruction = false;
-
-public:
-  FunctionOwnershipEvaluator() {}
-  FunctionOwnershipEvaluator(SILFunction *F) : F(F) {}
-  void reset(SILFunction *NewF) {
-    F = NewF;
-    HasOwnershipQualifiedInstruction = false;
-  }
-  bool evaluate(SILInstruction *I);
-};
-
 } // end namespace swift
 
 #endif

trunk/lib/AST/ASTPrinter.cpp

@@ -1344,22 +1344,21 @@ void PrintAST::printGenericSignature(const GenericSignature *genericSig,
                         // print everything
                         [&](const Requirement &) { return true; });
 }
+
 void PrintAST::printGenericSignature(
     const GenericSignature *genericSig, unsigned flags,
     llvm::function_ref<bool(const Requirement &)> filter) {
+  auto requirements = genericSig->getRequirements();
+
   if (flags & InnermostOnly) {
     auto genericParams = genericSig->getInnermostGenericParams();
-    unsigned depth = genericParams[0]->getDepth();
-    SmallVector<Requirement, 2> requirementsAtDepth;
-    getRequirementsAtDepth(genericSig, depth, requirementsAtDepth);
 
-    printSingleDepthOfGenericSignature(genericParams, requirementsAtDepth,
-                                       flags, filter);
+    printSingleDepthOfGenericSignature(genericParams, requirements, flags,
+                                       filter);
     return;
   }
 
   auto genericParams = genericSig->getGenericParams();
-  auto requirements = genericSig->getRequirements();
 
   if (!Options.PrintInSILBody) {
     printSingleDepthOfGenericSignature(genericParams, requirements, flags,
@@ -1966,15 +1965,24 @@ void PrintAST::printMembers(ArrayRef<Decl *> members, bool needComma,
 }
 
 void PrintAST::printGenericDeclGenericParams(GenericContext *decl) {
-  if (decl->getGenericParams())
+  if (decl->isGeneric())
     if (auto GenericSig = decl->getGenericSignature())
       printGenericSignature(GenericSig, PrintParams | InnermostOnly);
 }
 
 void PrintAST::printGenericDeclGenericRequirements(GenericContext *decl) {
-  if (decl->getGenericParams())
-    if (auto GenericSig = decl->getGenericSignature())
-      printGenericSignature(GenericSig, PrintRequirements | InnermostOnly);
+  if (decl->isGeneric()) {
+    if (auto genericSig = decl->getGenericSignature()) {
+      auto *baseGenericSig = decl->getParent()
+          ->getGenericSignatureOfContext();
+      printGenericSignature(genericSig, PrintRequirements,
+                            [baseGenericSig](const Requirement &req) {
+                              if (baseGenericSig)
+                                return !baseGenericSig->isRequirementSatisfied(req);
+                              return true;
+                            });
+    }
+  }
 }
 
 void PrintAST::printInherited(const Decl *decl) {
@@ -2115,7 +2123,7 @@ void PrintAST::printExtension(ExtensionDecl *decl) {
       auto *baseGenericSig = decl->getExtendedNominal()->getGenericSignature();
       assert(baseGenericSig &&
              "an extension can't be generic if the base type isn't");
-      printGenericSignature(genericSig, PrintRequirements | InnermostOnly,
+      printGenericSignature(genericSig, PrintRequirements,
                             [baseGenericSig](const Requirement &req) -> bool {
         // Only include constraints that are not satisfied by the base type.
         return !baseGenericSig->isRequirementSatisfied(req);

trunk/lib/ParseSIL/ParseSIL.cpp

@@ -229,7 +229,6 @@ namespace {
     SILParserTUState &TUState;
     SILFunction *F = nullptr;
     GenericEnvironment *ContextGenericEnv = nullptr;
-    FunctionOwnershipEvaluator OwnershipEvaluator;
 
   private:
     /// HadError - Have we seen an error parsing this function?
@@ -5335,16 +5334,6 @@ bool SILParser::parseSILBasicBlock(SILBuilder &B) {
   do {
     if (parseSILInstruction(B))
       return true;
-    // Evaluate how the just parsed instruction effects this functions Ownership
-    // Qualification. For more details, see the comment on the
-    // FunctionOwnershipEvaluator class.
-    SILInstruction *ParsedInst = &*BB->rbegin();
-    if (BB->getParent()->hasOwnership() &&
-        !OwnershipEvaluator.evaluate(ParsedInst)) {
-      P.diagnose(ParsedInst->getLoc().getSourceLoc(),
-                 diag::found_unqualified_instruction_in_qualified_function,
-                 F->getName());
-    }
   } while (isStartOfSILInstruction());
 
   return false;
@@ -5460,7 +5449,6 @@ bool SILParserTUState::parseDeclSIL(Parser &P) {
       }
 
       // Parse the basic block list.
-      FunctionState.OwnershipEvaluator.reset(FunctionState.F);
       SILOpenedArchetypesTracker OpenedArchetypesTracker(FunctionState.F);
       SILBuilder B(*FunctionState.F);
       // Track the archetypes just like SILGen. This

trunk/lib/SIL/InstructionUtils.cpp

@@ -527,94 +527,3 @@ void swift::findClosuresForFunctionValue(
     // Ignore other unrecognized values that feed this applied argument.
   }
 }
-
-namespace {
-
-enum class OwnershipQualifiedKind {
-  NotApplicable,
-  Qualified,
-  Unqualified,
-};
-
-struct OwnershipQualifiedKindVisitor : SILInstructionVisitor<OwnershipQualifiedKindVisitor, OwnershipQualifiedKind> {
-
-  OwnershipQualifiedKind visitSILInstruction(SILInstruction *I) {
-    return OwnershipQualifiedKind::NotApplicable;
-  }
-
-#define QUALIFIED_INST(CLASS) \
-  OwnershipQualifiedKind visit ## CLASS(CLASS *I) { \
-    return OwnershipQualifiedKind::Qualified;             \
-  }
-  QUALIFIED_INST(EndBorrowInst)
-  QUALIFIED_INST(LoadBorrowInst)
-  QUALIFIED_INST(CopyValueInst)
-  QUALIFIED_INST(DestroyValueInst)
-#define ALWAYS_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, ...) \
-  QUALIFIED_INST(Copy##Name##ValueInst)
-#include "swift/AST/ReferenceStorage.def"
-#undef QUALIFIED_INST
-
-  OwnershipQualifiedKind visitLoadInst(LoadInst *LI) {
-    if (LI->getOwnershipQualifier() == LoadOwnershipQualifier::Unqualified)
-      return OwnershipQualifiedKind::Unqualified;
-    return OwnershipQualifiedKind::Qualified;
-  }
-
-  OwnershipQualifiedKind visitStoreInst(StoreInst *SI) {
-    if (SI->getOwnershipQualifier() == StoreOwnershipQualifier::Unqualified)
-      return OwnershipQualifiedKind::Unqualified;
-    return OwnershipQualifiedKind::Qualified;
-  }
-};
-
-} // end anonymous namespace
-
-bool FunctionOwnershipEvaluator::evaluate(SILInstruction *I) {
-  assert(I->getFunction() == F.get() && "Can not evaluate function ownership "
-         "implications of an instruction that "
-         "does not belong to the instruction "
-         "that we are evaluating");
-
-  switch (OwnershipQualifiedKindVisitor().visit(I)) {
-  case OwnershipQualifiedKind::Unqualified: {
-    // If we already know that the function has unqualified ownership, just
-    // return early.
-    if (!F.get()->hasOwnership())
-      return true;
-
-    // Ok, so we know at this point that we have qualified ownership. If we have
-    // seen any instructions with qualified ownership, we have an error since
-    // the function mixes qualified and unqualified instructions.
-    if (HasOwnershipQualifiedInstruction)
-      return false;
-
-    // Otherwise, set the function to have unqualified ownership. This will
-    // ensure that no more Qualified instructions can be added to the given
-    // function.
-    F.get()->setOwnershipEliminated();
-    return true;
-  }
-  case OwnershipQualifiedKind::Qualified: {
-    // First check if our function has unqualified ownership. If we already do
-    // have unqualified ownership, then we know that we have already seen an
-    // unqualified ownership instruction. This means the function has both
-    // qualified and unqualified instructions. =><=.
-    if (!F.get()->hasOwnership())
-      return false;
-
-    // Ok, at this point we know that we are still qualified. Since functions
-    // start as qualified, we need to set the HasOwnershipQualifiedInstructions
-    // so we do not need to look back through the function if we see an
-    // unqualified instruction later on.
-    HasOwnershipQualifiedInstruction = true;
-    return true;
-  }
-  case OwnershipQualifiedKind::NotApplicable: {
-    // Not Applicable instr
-    return true;
-  }
-  }
-
-  llvm_unreachable("Unhandled OwnershipQualifiedKind in switch.");
-}

trunk/test/ParseableInterface/where-clause.swift

@@ -0,0 +1,54 @@
+// RUN: %empty-directory(%t)
+
+// RUN: %target-swift-frontend -typecheck %s -emit-module-interface-path %t/main.swiftinterface -enable-library-evolution
+// RUN: %FileCheck %s < %t/main.swiftinterface
+
+// RUN: %target-build-swift %s -emit-module-interface-path %t/main.swiftinterface -enable-library-evolution
+// RUN: %FileCheck %s < %t/main.swiftinterface
+
+// RUN: %target-build-swift %s -emit-module-interface-path %t/main.swiftinterface -enable-library-evolution -wmo
+// RUN: %FileCheck %s < %t/main.swiftinterface
+
+// CHECK: import Swift
+
+// CHECK: public struct Holder<Value> {
+public struct Holder<Value> {
+    var value: Value
+
+    // CHECK-NEXT: public init(value: Value){{$}}
+    public init(value: Value) {
+        self.value = value
+    }
+
+    // CHECK-NEXT: public init<T>(_ value: T) where Value == Swift.AnyHashable, T : Swift.Hashable{{$}}
+    public init<T : Hashable>(_ value: T) where Value == AnyHashable {
+        self.value = value
+    }
+
+    // CHECK-NEXT: public struct Transform<Result> {
+    public struct Transform<Result> {
+        var fn: (Value) -> Result
+
+        // CHECK-NEXT: public init(fn: @escaping (Value) -> Result){{$}}
+        public init(fn: @escaping (Value) -> Result) {
+            self.fn = fn
+        }
+
+        // CHECK-NEXT: func transform(_ holder: main.Holder<Value>) -> Result{{$}}
+        public func transform(_ holder: Holder<Value>) -> Result {
+            return fn(holder.value)
+        }
+    
+    // CHECK-NEXT: }
+    }
+
+// CHECK-NEXT: }
+}
+
+// CHECK-NEXT: extension Holder.Transform where Value == Swift.Int {
+extension Holder.Transform where Value == Int {
+    // CHECK-NEXT: public func negate(_ holder: main.Holder<Value>) -> Result{{$}}
+    public func negate(_ holder: Holder<Value>) -> Result {
+        return transform(Holder(value: -holder.value))
+    }
+}

trunk/test/SILGen/synthesized_conformance_class.swift

@@ -63,6 +63,34 @@ extension Nonfinal: Encodable where T: Encodable {}
 // CHECK-LABEL: // Nonfinal<A>.encode(to:)
 // CHECK-NEXT: sil hidden [ossa] @$s29synthesized_conformance_class8NonfinalCAASERzlE6encode2toys7Encoder_p_tKF : $@convention(method) <T where T : Encodable> (@in_guaranteed Encoder, @guaranteed Nonfinal<T>) -> @error Error {
 
+final class FinalHashableClass : Hashable {
+  static func ==(lhs: FinalHashableClass, rhs: FinalHashableClass) -> Bool {
+    return false
+  }
+
+  func hash(into: inout Hasher) {}
+}
+
+// CHECK-LABEL: sil hidden [ossa] @$s29synthesized_conformance_class4doItySiAA18FinalHashableClassCF : $@convention(thin) (@guaranteed FinalHashableClass) -> Int {
+// CHECK: bb0(%0 : @guaranteed $FinalHashableClass):
+// CHECK:   [[FN:%.*]] = function_ref @$s29synthesized_conformance_class18FinalHashableClassC9hashValueSivg : $@convention(method) (@guaranteed FinalHashableClass) -> Int
+// CHECK-NEXT: [[RESULT:%.*]] = apply [[FN]](%0) : $@convention(method) (@guaranteed FinalHashableClass) -> Int
+// CHECK-NEXT: return [[RESULT]] : $Int
+
+func doIt(_ c: FinalHashableClass) -> Int {
+  return c.hashValue
+}
+
+// VTable for FinalHashableClass
+//
+// Note: we should not be emitting a vtable entry for the synthesized
+// FinalHashableClass.hashValue getter!
+
+// CHECK: sil_vtable FinalHashableClass {
+// CHECK-NEXT: #FinalHashableClass.init!allocator.1: (FinalHashableClass.Type) -> () -> FinalHashableClass : @$s29synthesized_conformance_class18FinalHashableClassCACycfC
+// CHECK-NEXT: #FinalHashableClass.deinit!deallocator.1: @$s29synthesized_conformance_class18FinalHashableClassCfD
+// CHECK-NEXT: }
+
 // Witness tables for Final
 
 // CHECK-LABEL: sil_witness_table hidden <T where T : Encodable> Final<T>: Encodable module synthesized_conformance_class {