---

yaml
---
r: 314363
b: refs/heads/master
c: 6674043
h: refs/heads/master
i:
  314361: d813b75
  314359: ac56655

Author: slavapestov

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 57f6fc203f0c927fb476444188b6554a2e9d7462
+refs/heads/master: 667404345450b4a9eb83c0620daa233044955ea3
 refs/heads/master-next: 66a7e661ff8e88e2d4efab3e430197a7a941e352
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/include/swift/Basic/STLExtras.h

@@ -862,6 +862,17 @@ Iterator removeAdjacentIf(const Iterator first, const Iterator last,
   return insertionPoint;
 }
 
+namespace detail {
+template <bool...> struct bool_pack;
+} // namespace detail
+
+template <bool... b>
+using all_true =
+    std::is_same<detail::bool_pack<b..., true>, detail::bool_pack<true, b...>>;
+
+/// traits class for checking whether Ts consists only of compound types.
+template <class... Ts>
+using are_all_compound = all_true<std::is_compound<Ts>::value...>;
 
 } // end namespace swift
 

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/Frontend/ParseableInterfaceModuleLoader.h

@@ -9,6 +9,7 @@
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
+///
 /// \file This implements the logic for loading and building parseable module
 /// interfaces.
 ///
@@ -102,22 +103,25 @@
 ///
 //===----------------------------------------------------------------------===//
 
+#ifndef SWIFT_FRONTEND_PARSEABLEINTERFACEMODULELOADER_H
+#define SWIFT_FRONTEND_PARSEABLEINTERFACEMODULELOADER_H
+
 #include "swift/Basic/LLVM.h"
 #include "swift/Frontend/ParseableInterfaceSupport.h"
 #include "swift/Serialization/SerializedModuleLoader.h"
 
 namespace clang {
-  class CompilerInstance;
+class CompilerInstance;
 }
 
 namespace unittest {
-  class ParseableInterfaceModuleLoaderTest;
+class ParseableInterfaceModuleLoaderTest;
 }
 
 namespace swift {
 
-  class LangOptions;
-  class SearchPathOptions;
+class LangOptions;
+class SearchPathOptions;
 
 /// A ModuleLoader that runs a subordinate \c CompilerInvocation and
 /// \c CompilerInstance to convert .swiftinterface files to .swiftmodule
@@ -182,3 +186,5 @@ std::string
 getModuleCachePathFromClang(const clang::CompilerInstance &Instance);
 
 }
+
+#endif

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