---

yaml
---
r: 314361
b: refs/heads/master
c: 0fd8d07
h: refs/heads/master
i:
  314359: ac56655

Author: swift-ci

[refs]

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

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/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.");
-}