---

yaml
---
r: 341823
b: refs/heads/rxwei-patch-1
c: 5969aca
h: refs/heads/master
i:
  341821: cc9ba5c
  341819: 38add50
  341815: 7db2dda
  341807: 7b33332
  341791: ca6d2b8
  341759: cf9612b

Author: slavapestov

[refs]

@@ -1015,7 +1015,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-08-18-a: b10b1fce14385faa6d44f6b933e95
 refs/heads/rdar-43033749-fix-batch-mode-no-diags-swift-5.0-branch: a14e64eaad30de89f0f5f0b2a782eed7ecdcb255
 refs/heads/revert-19006-error-bridging-integer-type: 8a9065a3696535305ea53fe9b71f91cbe6702019
 refs/heads/revert-19050-revert-19006-error-bridging-integer-type: ecf752d54b05dd0a20f510f0bfa54a3fec3bcaca
-refs/heads/rxwei-patch-1: e16eb86bc0a880332afce996f7739aec9a516f18
+refs/heads/rxwei-patch-1: 5969aca6b117f4e0d72344927ae8a74e30f8e300
 refs/heads/shahmishal-patch-1: e58ec0f7488258d42bef51bc3e6d7b3dc74d7b2a
 refs/heads/typelist-existential: 4046359efd541fb5c72d69a92eefc0a784df8f5e
 refs/tags/swift-4.2-DEVELOPMENT-SNAPSHOT-2018-08-20-a: 4319ba09e4fb8650ee86061075c74a016b6baab9

branches/rxwei-patch-1/include/swift/AST/Decl.h

@@ -5773,6 +5773,11 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
     setBodyKind(BodyKind::Unparsed);
   }
 
+  /// Provide the parsed body for the function.
+  void setBodyParsed(BraceStmt *S) {
+    setBody(S, BodyKind::Parsed);
+  }
+
   /// Note that parsing for the body was delayed.
   ///
   /// The function should return the body statement and a flag indicating
@@ -5793,14 +5798,6 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
     setBodyKind(BodyKind::MemberwiseInitializer);
   }
 
-  /// If a body has been loaded, flag that it's been type-checked.
-  /// This is kindof a hacky operation, but it avoids some unnecessary
-  /// duplication of work.
-  void setBodyTypeCheckedIfPresent() {
-    if (getBodyKind() == BodyKind::Parsed)
-      setBodyKind(BodyKind::TypeChecked);
-  }
-
   /// Gets the body of this function, stripping the unused portions of #if
   /// configs inside the body. If this function was not deserialized from a
   /// .swiftmodule, this body is reconstructed from the original

branches/rxwei-patch-1/include/swift/AST/DiagnosticsDriver.def

@@ -166,6 +166,9 @@ WARNING(warn_use_filelists_deprecated, none,
 ERROR(cannot_find_migration_script, none,
       "missing migration script from path '%0'", (StringRef))
 
+ERROR(error_darwin_static_stdlib_not_supported, none,
+      "-static-stdlib is no longer supported on Apple platforms", ())
+
 #ifndef DIAG_NO_UNDEF
 # if defined(DIAG)
 #  undef DIAG

branches/rxwei-patch-1/include/swift/AST/Expr.h

@@ -954,8 +954,14 @@ class InterpolatedStringLiteralExpr : public LiteralExpr {
   /// would not work for \c stringLiteral->getEndLoc().
   SourceLoc TrailingQuoteLoc;
   TapExpr *AppendingExpr;
-  Expr *SemanticExpr;
-  
+
+  // Set by Sema:
+  OpaqueValueExpr *interpolationExpr = nullptr;
+  ConcreteDeclRef builderInit;
+  ConcreteDeclRef resultInit;
+  Expr *interpolationCountExpr = nullptr;
+  Expr *literalCapacityExpr = nullptr;
+
 public:
   InterpolatedStringLiteralExpr(SourceLoc Loc,
                                 SourceLoc TrailingQuoteLoc,
@@ -965,11 +971,35 @@ class InterpolatedStringLiteralExpr : public LiteralExpr {
       : LiteralExpr(ExprKind::InterpolatedStringLiteral, /*Implicit=*/false),
         Loc(Loc),
         TrailingQuoteLoc(TrailingQuoteLoc),
-        AppendingExpr(AppendingExpr), SemanticExpr() {
+        AppendingExpr(AppendingExpr) {
     Bits.InterpolatedStringLiteralExpr.InterpolationCount = InterpolationCount;
     Bits.InterpolatedStringLiteralExpr.LiteralCapacity = LiteralCapacity;
   }
 
+  // Sets the constructor for the interpolation type.
+  void setBuilderInit(ConcreteDeclRef decl) { builderInit = decl; }
+  ConcreteDeclRef getBuilderInit() const { return builderInit; }
+
+  /// Sets the decl that constructs the final result type after the
+  /// AppendingExpr has been evaluated.
+  void setResultInit(ConcreteDeclRef decl) { resultInit = decl; }
+  ConcreteDeclRef getResultInit() const { return resultInit; }
+
+  /// Sets the OpaqueValueExpr that is passed into AppendingExpr as the SubExpr
+  /// that the tap operates on.
+  void setInterpolationExpr(OpaqueValueExpr *expr) { interpolationExpr = expr; }
+  OpaqueValueExpr *getInterpolationExpr() const { return interpolationExpr; }
+
+  /// Store a builtin integer literal expr wrapping getInterpolationCount().
+  /// This is an arg to builderInit.
+  void setInterpolationCountExpr(Expr *expr) { interpolationCountExpr = expr; }
+  Expr *getInterpolationCountExpr() const { return interpolationCountExpr; }
+
+  /// Store a builtin integer literal expr wrapping getLiteralCapacity().
+  /// This is an arg to builderInit.
+  void setLiteralCapacityExpr(Expr *expr) { literalCapacityExpr = expr; }
+  Expr *getLiteralCapacityExpr() const { return literalCapacityExpr; }
+
   /// Retrieve the value of the literalCapacity parameter to the
   /// initializer.
   unsigned getLiteralCapacity() const {
@@ -989,11 +1019,6 @@ class InterpolatedStringLiteralExpr : public LiteralExpr {
   TapExpr * getAppendingExpr() const { return AppendingExpr; }
   void setAppendingExpr(TapExpr * AE) { AppendingExpr = AE; }
 
-  /// Retrieve the expression that actually evaluates the resulting
-  /// string, typically with a series of '+' operations.
-  Expr *getSemanticExpr() const { return SemanticExpr; }
-  void setSemanticExpr(Expr *SE) { SemanticExpr = SE; }
-  
   SourceLoc getStartLoc() const {
     return Loc;
   }

branches/rxwei-patch-1/include/swift/AST/SimpleRequest.h

@@ -113,9 +113,7 @@ namespace detail {
 
   /// Extract the first, nearest source location from a tuple.
   template<unsigned Index, typename ...Types,
-           typename = typename std::enable_if<sizeof...(Types) - Index
-                                                  ? true
-                                                  : false>::type>
+           typename = typename std::enable_if<(Index < sizeof...(Types))>::type>
   SourceLoc extractNearestSourceLocTuple(const std::tuple<Types...> &value) {
     SourceLoc loc = maybeExtractNearestSourceLoc(std::get<Index>(value));
     if (loc.isValid())

branches/rxwei-patch-1/include/swift/AST/TypeCheckRequests.h

@@ -689,13 +689,14 @@ class LazyStoragePropertyRequest :
   bool isCached() const { return true; }
 };
 
-/// Request to type check the body of the given function.
+/// Request to type check the body of the given function up to the given
+/// source location.
 ///
 /// Produces true if an error occurred, false otherwise.
 /// FIXME: it would be far better to return the type-checked body.
-class TypeCheckFunctionBodyRequest :
-    public SimpleRequest<TypeCheckFunctionBodyRequest,
-                         bool(AbstractFunctionDecl *),
+class TypeCheckFunctionBodyUntilRequest :
+    public SimpleRequest<TypeCheckFunctionBodyUntilRequest,
+                         bool(AbstractFunctionDecl *, SourceLoc),
                          CacheKind::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -705,7 +706,8 @@ class TypeCheckFunctionBodyRequest :
 
   // Evaluation.
   llvm::Expected<bool>
-  evaluate(Evaluator &evaluator, AbstractFunctionDecl *func) const;
+  evaluate(Evaluator &evaluator, AbstractFunctionDecl *func,
+           SourceLoc endTypeCheckLoc) const;
 
 public:
   bool isCached() const { return true; }

branches/rxwei-patch-1/include/swift/AST/TypeCheckerTypeIDZone.def

@@ -40,4 +40,4 @@ SWIFT_TYPEID(IsGetterMutatingRequest)
 SWIFT_TYPEID(IsSetterMutatingRequest)
 SWIFT_TYPEID(OpaqueReadOwnershipRequest)
 SWIFT_TYPEID(LazyStoragePropertyRequest)
-SWIFT_TYPEID(TypeCheckFunctionBodyRequest)
+SWIFT_TYPEID(TypeCheckFunctionBodyUntilRequest)

branches/rxwei-patch-1/include/swift/Basic/SourceLoc.h

@@ -78,6 +78,14 @@ class SourceLoc {
   }
 
   void dump(const SourceManager &SM) const;
+
+	friend size_t hash_value(SourceLoc loc) {
+		return reinterpret_cast<uintptr_t>(loc.getOpaquePointerValue());
+	}
+
+	friend void simple_display(raw_ostream &OS, const SourceLoc &loc) {
+		// Nothing meaningful to print.
+	}
 };
 
 /// SourceRange in swift is a pair of locations.  However, note that the end

branches/rxwei-patch-1/include/swift/Driver/ToolChain.h

@@ -24,6 +24,8 @@
 #include <memory>
 
 namespace swift {
+class DiagnosticEngine;
+
 namespace driver {
 class CommandOutput;
 class Compilation;
@@ -302,6 +304,13 @@ class ToolChain {
   void addLinkRuntimeLib(const llvm::opt::ArgList &Args,
                          llvm::opt::ArgStringList &Arguments,
                          StringRef LibName) const;
+    
+  /// Validates arguments passed to the toolchain.
+  ///
+  /// An override point for platform-specific subclasses to customize the
+  /// validations that should be performed.
+  virtual void validateArguments(DiagnosticEngine &diags,
+                                 const llvm::opt::ArgList &args) const {}
 };
 } // end namespace driver
 } // end namespace swift

branches/rxwei-patch-1/lib/AST/ASTDumper.cpp

@@ -1949,9 +1949,13 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
     PrintWithColorRAII(OS, LiteralValueColor)
       << " literal_capacity="
       << E->getLiteralCapacity() << " interpolation_count="
-      << E->getInterpolationCount() << '\n';
+      << E->getInterpolationCount();
+    PrintWithColorRAII(OS, LiteralValueColor) << " builder_init=";
+    E->getBuilderInit().dump(PrintWithColorRAII(OS, LiteralValueColor).getOS());
+    PrintWithColorRAII(OS, LiteralValueColor) << " result_init=";
+    E->getResultInit().dump(PrintWithColorRAII(OS, LiteralValueColor).getOS());
+    OS << "\n";
     printRec(E->getAppendingExpr());
-    printSemanticExpr(E->getSemanticExpr());
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
   void visitMagicIdentifierLiteralExpr(MagicIdentifierLiteralExpr *E) {
@@ -3772,4 +3776,4 @@ StringRef swift::getAccessorKindString(AccessorKind value) {
   }
 
   llvm_unreachable("Unhandled AccessorKind in switch.");
-}
+}

branches/rxwei-patch-1/lib/AST/ASTVerifier.cpp

@@ -804,6 +804,26 @@ class Verifier : public ASTWalker {
       OpaqueValues.erase(S->getElementExpr());
     }
 
+    bool shouldVerify(InterpolatedStringLiteralExpr *expr) {
+      if (!shouldVerify(cast<Expr>(expr)))
+        return false;
+
+      if (!expr->getInterpolationExpr())
+        return true;
+
+      assert(!OpaqueValues.count(expr->getInterpolationExpr()));
+      OpaqueValues[expr->getInterpolationExpr()] = 0;
+      return true;
+    }
+
+    void cleanup(InterpolatedStringLiteralExpr *expr) {
+      if (!expr->getInterpolationExpr())
+        return;
+
+      assert(OpaqueValues.count(expr->getInterpolationExpr()));
+      OpaqueValues.erase(expr->getInterpolationExpr());
+    }
+
     bool shouldVerify(OpenExistentialExpr *expr) {
       if (!shouldVerify(cast<Expr>(expr)))
         return false;

branches/rxwei-patch-1/lib/AST/ASTWalker.cpp

@@ -472,8 +472,6 @@ class Traversal : public ASTVisitor<Traversal, Expr*, Stmt*,
   }
 
   Expr *visitInterpolatedStringLiteralExpr(InterpolatedStringLiteralExpr *E) {
-    HANDLE_SEMANTIC_EXPR(E);
-
     if (auto oldAppendingExpr = E->getAppendingExpr()) {
       if (auto appendingExpr = doIt(oldAppendingExpr))
         E->setAppendingExpr(dyn_cast<TapExpr>(appendingExpr));

branches/rxwei-patch-1/lib/AST/Decl.cpp

@@ -3775,6 +3775,14 @@ DestructorDecl *ClassDecl::getDestructor() {
   return cast<DestructorDecl>(results.front());
 }
 
+/// Synthesizer callback for an empty implicit function body.
+static std::pair<BraceStmt *, bool>
+synthesizeEmptyFunctionBody(AbstractFunctionDecl *afd, void *context) {
+  ASTContext &ctx = afd->getASTContext();
+  return { BraceStmt::create(ctx, afd->getLoc(), { }, afd->getLoc(), true),
+           /*isTypeChecked=*/true };
+}
+
 void ClassDecl::addImplicitDestructor() {
   if (hasDestructor() || isInvalid())
     return;
@@ -3785,8 +3793,8 @@ void ClassDecl::addImplicitDestructor() {
   DD->setImplicit();
   DD->setValidationToChecked();
 
-  // Create an empty body for the destructor.
-  DD->setBody(BraceStmt::create(ctx, getLoc(), { }, getLoc(), true));
+  // Synthesize an empty body for the destructor as needed.
+  DD->setBodySynthesizer(synthesizeEmptyFunctionBody);
   addMember(DD);
 
   // Propagate access control and versioned-ness.

branches/rxwei-patch-1/lib/AST/Expr.cpp

@@ -2191,16 +2191,6 @@ void KeyPathExpr::Component::setSubscriptIndexHashableConformances(
 void InterpolatedStringLiteralExpr::forEachSegment(ASTContext &Ctx, 
     llvm::function_ref<void(bool, CallExpr *)> callback) {
   auto appendingExpr = getAppendingExpr();
-  if (SemanticExpr) {
-    SemanticExpr->forEachChildExpr([&](Expr *subExpr) -> Expr * {
-      if (auto tap = dyn_cast_or_null<TapExpr>(subExpr)) {
-        appendingExpr = tap;
-        return nullptr;
-      }
-      return subExpr;
-    });
-  }
-
   for (auto stmt : appendingExpr->getBody()->getElements()) {
     if (auto expr = stmt.dyn_cast<Expr*>()) {
       if (auto call = dyn_cast<CallExpr>(expr)) {

branches/rxwei-patch-1/lib/ClangImporter/ImportName.cpp

@@ -1729,9 +1729,14 @@ ImportedName NameImporter::importNameImpl(const clang::NamedDecl *D,
 
 /// Returns true if it is expected that the macro is ignored.
 static bool shouldIgnoreMacro(StringRef name, const clang::MacroInfo *macro) {
-  // Ignore include guards.
-  if (macro->isUsedForHeaderGuard())
-    return true;
+  // Ignore include guards. Try not to ignore definitions of useful constants,
+  // which may end up looking like include guards.
+  if (macro->isUsedForHeaderGuard() && macro->getNumTokens() == 1) {
+    auto tok = macro->tokens()[0];
+    if (tok.isLiteral()
+        && StringRef(tok.getLiteralData(), tok.getLength()) == "1")
+      return true;
+  }
 
   // If there are no tokens, there is nothing to convert.
   if (macro->tokens_empty())

branches/rxwei-patch-1/lib/Driver/DarwinToolChains.cpp

@@ -12,6 +12,7 @@
 
 #include "ToolChains.h"
 
+#include "swift/AST/DiagnosticsDriver.h"
 #include "swift/Basic/Dwarf.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/Platform.h"
@@ -442,13 +443,9 @@ toolchains::Darwin::constructInvocation(const DynamicLinkJobAction &job,
       }
   }
 
-  bool wantsStaticStdlib =
-      context.Args.hasFlag(options::OPT_static_stdlib,
-                           options::OPT_no_static_stdlib, false);
-
   SmallVector<std::string, 4> RuntimeLibPaths;
   getRuntimeLibraryPaths(RuntimeLibPaths, context.Args,
-                         context.OI.SDKPath, /*Shared=*/!wantsStaticStdlib);
+                         context.OI.SDKPath, /*Shared=*/true);
 
   // Add the runtime library link path, which is platform-specific and found
   // relative to the compiler.
@@ -457,19 +454,11 @@ toolchains::Darwin::constructInvocation(const DynamicLinkJobAction &job,
     Arguments.push_back(context.Args.MakeArgString(path));
   }
 
-  // Link the standard library.
-  if (wantsStaticStdlib) {
-    Arguments.push_back("-lc++");
-    Arguments.push_back("-framework");
-    Arguments.push_back("Foundation");
-    Arguments.push_back("-force_load_swift_libs");
-  } else {
-    // FIXME: We probably shouldn't be adding an rpath here unless we know ahead
-    // of time the standard library won't be copied. SR-1967
-    for (auto path : RuntimeLibPaths) {
-      Arguments.push_back("-rpath");
-      Arguments.push_back(context.Args.MakeArgString(path));
-    }
+  // FIXME: We probably shouldn't be adding an rpath here unless we know ahead
+  // of time the standard library won't be copied. SR-1967
+  for (auto path : RuntimeLibPaths) {
+    Arguments.push_back("-rpath");
+    Arguments.push_back(context.Args.MakeArgString(path));
   }
 
   if (context.Args.hasArg(options::OPT_profile_generate)) {
@@ -595,3 +584,12 @@ bool toolchains::Darwin::shouldStoreInvocationInDebugInfo() const {
     return S[0] != '\0';
   return false;
 }
+
+void 
+toolchains::Darwin::validateArguments(DiagnosticEngine &diags,
+                                      const llvm::opt::ArgList &args) const {
+  // Validating darwin unsupported -static-stdlib argument.
+  if (args.hasArg(options::OPT_static_stdlib)) {
+    diags.diagnose(SourceLoc(), diag::error_darwin_static_stdlib_not_supported);
+  }
+}

branches/rxwei-patch-1/lib/Driver/Driver.cpp

@@ -820,7 +820,11 @@ Driver::buildCompilation(const ToolChain &TC,
   std::unique_ptr<DerivedArgList> TranslatedArgList(
       translateInputAndPathArgs(*ArgList, workingDirectory));
 
+  // TODO: We should check which validations could be moved to toolchain specific classes.
   validateArgs(Diags, *TranslatedArgList);
+    
+  // Perform toolchain specific args validation.
+  TC.validateArguments(Diags, *TranslatedArgList);
 
   if (Diags.hadAnyError())
     return nullptr;