---

yaml
---
r: 294767
b: refs/heads/tensorflow
c: e80b965
h: refs/heads/master
i:
  294765: d73f061
  294763: 0b7e2a0
  294759: eb3937a
  294751: 24b3328

Author: swift-ci

[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: 8daa0348edf1e5b94b6faa9148a0465617861491
+refs/heads/tensorflow: e80b965e794db766d92d274934a043ea2ccdf5a1
 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/docs/SIL.rst

@@ -2337,7 +2337,7 @@ assign_by_delegate
 ``````````````````
 ::
 
-  sil-instruction ::= 'assign_by_delegate' sil-operand 'to' sil-operand ',' 'init' sil-operand ',' 'set' sil-operand 
+  sil-instruction ::= 'assign_by_delegate' sil-operand 'to' sil-operand ',' 'init' sil-operand ',' 'set' sil-operand
 
   assign_by_delegate %0 : $S to %1 : $*T, init %2 : $F, set %3 : $G
   // $S can be a value or address type
@@ -3054,7 +3054,7 @@ function_ref
 Creates a reference to a SIL function.
 
 dynamic_function_ref
-````````````
+````````````````````
 ::
 
   sil-instruction ::= 'dynamic_function_ref' sil-function-name ':' sil-type
@@ -3091,7 +3091,7 @@ We will generate::
   }
 
 prev_dynamic_function_ref
-````````````
+`````````````````````````
 ::
 
   sil-instruction ::= 'prev_dynamic_function_ref' sil-function-name ':' sil-type

branches/tensorflow/lib/AST/DiagnosticEngine.cpp

@@ -622,10 +622,14 @@ static DiagnosticKind toDiagnosticKind(DiagnosticState::Behavior behavior) {
   llvm_unreachable("Unhandled DiagnosticKind in switch.");
 }
 
-/// A special option only for compiler writers that causes Diagnostics to assert
-/// when a failure diagnostic is emitted. Intended for use in the debugger.
+// A special option only for compiler writers that causes Diagnostics to assert
+// when a failure diagnostic is emitted. Intended for use in the debugger.
 llvm::cl::opt<bool> AssertOnError("swift-diagnostics-assert-on-error",
                                   llvm::cl::init(false));
+// A special option only for compiler writers that causes Diagnostics to assert
+// when a warning diagnostic is emitted. Intended for use in the debugger.
+llvm::cl::opt<bool> AssertOnWarning("swift-diagnostics-assert-on-warning",
+                                    llvm::cl::init(false));
 
 DiagnosticState::Behavior DiagnosticState::determineBehavior(DiagID id) {
   auto set = [this](DiagnosticState::Behavior lvl) {
@@ -637,6 +641,8 @@ DiagnosticState::Behavior DiagnosticState::determineBehavior(DiagID id) {
     }
 
     assert((!AssertOnError || !anyErrorOccurred) && "We emitted an error?!");
+    assert((!AssertOnWarning || (lvl != Behavior::Warning)) &&
+           "We emitted a warning?!");
     previousBehavior = lvl;
     return lvl;
   };

branches/tensorflow/lib/IDE/SyntaxModel.cpp

@@ -56,7 +56,6 @@ SyntaxModelContext::SyntaxModelContext(SourceFile &SrcFile)
   std::vector<SyntaxNode> Nodes;
   SourceLoc AttrLoc;
   SourceLoc UnaryMinusLoc;
-  auto LiteralStartLoc = Optional<SourceLoc>();
   for (unsigned I = 0, E = Tokens.size(); I != E; ++I) {
     auto &Tok = Tokens[I];
     // Ignore empty string literals between interpolations, e.g. "\(1)\(2)"
@@ -85,16 +84,6 @@ SyntaxModelContext::SyntaxModelContext(SourceFile &SrcFile)
       Loc = Tok.getLoc();
       Length = Tok.getLength();
 
-      if (LiteralStartLoc.hasValue() && Length.hasValue()) {
-        if (Tok.getKind() != tok::r_paren)
-          continue;
-        Kind = SyntaxNodeKind::ObjectLiteral;
-        Nodes.emplace_back(Kind, CharSourceRange(SM, LiteralStartLoc.getValue(),
-                                                 Tok.getRange().getEnd()));
-        LiteralStartLoc = Optional<SourceLoc>();
-        continue;
-      }
-
       switch(Tok.getKind()) {
 #define KEYWORD(X) case tok::kw_##X:
 #include "swift/Syntax/TokenKinds.def"
@@ -105,8 +94,8 @@ SyntaxModelContext::SyntaxModelContext(SourceFile &SrcFile)
 
 #define POUND_OBJECT_LITERAL(Name, Desc, Proto) case tok::pound_##Name:
 #include "swift/Syntax/TokenKinds.def"
-        LiteralStartLoc = Loc;
-        continue;
+        Kind = SyntaxNodeKind::Keyword;
+        break;
 
 #define POUND_COND_DIRECTIVE_KEYWORD(Name) case tok::pound_##Name:
 #include "swift/Syntax/TokenKinds.def"
@@ -260,6 +249,9 @@ class ModelASTWalker : public ASTWalker {
   Optional<SyntaxNode> parseFieldNode(StringRef Text, StringRef OrigText,
                                       SourceLoc OrigLoc);
   llvm::DenseSet<ASTNode> VisitedNodesInsideIfConfig;
+  /// When non-zero, we should avoid passing tokens as syntax nodes since a parent of several tokens
+  /// is considered as one, e.g. object literal expression.
+  uint8_t AvoidPassingSyntaxToken = 0;
 
 public:
   SyntaxModelWalker &Walker;
@@ -494,8 +486,9 @@ std::pair<bool, Expr *> ModelASTWalker::walkToExprPre(Expr *E) {
     SN.NameRange = CharSourceRange(SM, NRStart, NREnd);
     SN.BodyRange =
       innerCharSourceRangeFromSourceRange(SM, ObjectE->getSourceRange());
+    // Consider the object literal as a single syntax token for highlighting.
+    passNonTokenNode({SyntaxNodeKind::ObjectLiteral, SN.Range});
     pushStructureNode(SN, E);
-
   } else if (auto *ArrayE = dyn_cast<ArrayExpr>(E)) {
     SyntaxStructureNode SN;
     SN.Kind = SyntaxStructureKind::ArrayExpression;
@@ -1152,8 +1145,10 @@ bool ModelASTWalker::passTokenNodesUntil(SourceLoc Loc,
       }
       break;
     }
-    if (!passNode(TokenNodes[I]))
-      return false;
+    if (!AvoidPassingSyntaxToken) {
+      if (!passNode(TokenNodes[I]))
+        return false;
+    }
   }
 
   TokenNodes = TokenNodes.slice(I);
@@ -1200,9 +1195,15 @@ bool ModelASTWalker::passNode(const SyntaxNode &Node) {
   return Walker.walkToNodePost(Node);
 }
 
+static bool shouldAvoidPssingSyntaxToken(const SyntaxStructureNode &Node) {
+  return Node.Kind == SyntaxStructureKind::ObjectLiteralExpression;
+}
+
 bool ModelASTWalker::pushStructureNode(const SyntaxStructureNode &Node,
                                        const ASTNodeType& ASTNode) {
   SubStructureStack.emplace_back(Node, ASTNode);
+  if (shouldAvoidPssingSyntaxToken(Node))
+    AvoidPassingSyntaxToken ++;
 
   if (!passTokenNodesUntil(Node.Range.getStart(), ExcludeNodeAtLocation))
     return false;
@@ -1215,6 +1216,12 @@ bool ModelASTWalker::pushStructureNode(const SyntaxStructureNode &Node,
 bool ModelASTWalker::popStructureNode() {
   assert(!SubStructureStack.empty());
   SyntaxStructureNode Node = SubStructureStack.back().StructureNode;
+  SWIFT_DEFER {
+    if (shouldAvoidPssingSyntaxToken(Node)) {
+      assert(AvoidPassingSyntaxToken);
+      AvoidPassingSyntaxToken --;
+    }
+  };
   SubStructureStack.pop_back();
 
   // VarDecls are popped before we see their TypeRepr, so if we pass the token

branches/tensorflow/lib/SILOptimizer/Mandatory/DiagnoseUnreachable.cpp

@@ -529,15 +529,20 @@ static bool simplifyBlocksWithCallsToNoReturn(SILBasicBlock &BB,
       // Diagnose the unreachable code within the same block as the call to
       // noreturn.
       if (isUserCode(CurrentInst) && !DiagnosedUnreachableCode) {
-        if (NoReturnCall->getLoc().is<RegularLocation>()) {
-          if (!NoReturnCall->getLoc().isASTNode<ExplicitCastExpr>()) {
-            diagnose(BB.getModule().getASTContext(),
-                     CurrentInst->getLoc().getSourceLoc(),
-                     diag::unreachable_code);
-            diagnose(BB.getModule().getASTContext(),
-                     NoReturnCall->getLoc().getSourceLoc(),
-                     diag::call_to_noreturn_note);
-            DiagnosedUnreachableCode = true;
+        // If we have an instruction that is an end_borrow, ignore it. This
+        // happens when passing a guaranteed argument through generic code paths
+        // to no return functions.
+        if (!isa<EndBorrowInst>(CurrentInst)) {
+          if (NoReturnCall->getLoc().is<RegularLocation>()) {
+            if (!NoReturnCall->getLoc().isASTNode<ExplicitCastExpr>()) {
+              diagnose(BB.getModule().getASTContext(),
+                       CurrentInst->getLoc().getSourceLoc(),
+                       diag::unreachable_code);
+              diagnose(BB.getModule().getASTContext(),
+                       NoReturnCall->getLoc().getSourceLoc(),
+                       diag::call_to_noreturn_note);
+              DiagnosedUnreachableCode = true;
+            }
           }
         }
       }

branches/tensorflow/test/IDE/coloring.swift

@@ -262,6 +262,9 @@ func bar(x: Int) -> (Int, Float) {
   foo(Float())
 }
 
+// CHECK: <object-literal>#colorLiteral(red: 1.0, green: 1.0, blue: 1.0, alpha: 1.0)</object-literal>
+#colorLiteral(red: 1.0, green: 1.0, blue: 1.0, alpha: 1.0)
+
 class GenC<T1,T2> {}
 
 func test() {
@@ -277,6 +280,9 @@ func test2(x: Int) {
   "\(x)"
 }
 
+// CHECK: <kw>#colorLiteral</kw>
+#colorLiteral
+
 // CHECK: <kw>class</kw> Observers {
 class Observers {
   // CHECK: <kw>var</kw> p1 : <type>Int</type> {

branches/tensorflow/test/Interpreter/Inputs/testable_key_path_2.swift

@@ -0,0 +1,3 @@
+internal class TestClass {
+  internal var field = "goodbye"
+}

branches/tensorflow/test/Interpreter/testable_key_path.swift

@@ -0,0 +1,20 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-build-swift -force-single-frontend-invocation -c -o %t/Module.o -enable-testing -parse-as-library -emit-module -emit-module-path %t/Module.swiftmodule -module-name Module %S/Inputs/testable_key_path_2.swift
+// RUN: %target-build-swift -o %t/a.out -I %t %s %t/Module.o
+// RUN: %target-run %t/a.out | %FileCheck %s
+
+// REQUIRES: executable_test
+
+@testable import Module
+
+let c = TestClass()
+
+print("You say \(c.field)")
+
+let kp = \TestClass.field
+
+c[keyPath: kp] = "hello"
+
+print("I say \(c.field)")
+
+// CHECK: I say hello

branches/tensorflow/test/Runtime/crash_without_backtrace_optimized.swift

@@ -23,8 +23,21 @@
 
 import Swift
 
+#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
+  import Darwin
+#elseif os(Linux) || os(FreeBSD) || os(PS4) || os(Android) || os(Cygwin) || os(Haiku)
+  import Glibc
+#elseif os(Windows)
+  import MSVCRT
+#else
+#error("Unsupported platform")
+#endif
+
 func foo() -> Int {
   return UnsafePointer<Int>(bitPattern: 0)!.pointee
 }
 
+// Give FileCheck something to look at to keep it happy. It fails on
+// empty output even if the only directive is a CHECK-NOT.
+fputs("Running test.\n", stderr)
 foo()

branches/tensorflow/test/SILOptimizer/return_ownership.swift

@@ -0,0 +1,17 @@
+// RUN: %target-swift-frontend %s -enable-ownership-stripping-after-serialization -emit-sil -verify
+
+class TuringMachine {
+  func halt() -> Never {
+    repeat { } while true
+  }
+}
+
+func diagnose_missing_return_no_error_after_noreturn_method() -> Int {
+  TuringMachine().halt()
+} // no error
+
+func testUnreachableAfterNoReturnMethod() -> Int {
+  TuringMachine().halt(); // expected-note{{a call to a never-returning function}}
+  return 0; // expected-warning {{will never be executed}}
+}
+

branches/tensorflow/test/stdlib/Inputs/NSSlowString/NSSlowString.m

@@ -18,6 +18,12 @@ - (instancetype)initWithString:(NSString *)name {
 	return self;
 }
 
+- (instancetype)initWithCharacters:(const unichar * _Nonnull)chars length:(NSUInteger)count {
+  NSString *str = [[NSString alloc] initWithCharacters: chars length: count];
+  self = [self initWithString: str];
+  return self;
+}
+
 - (NSUInteger)length {
     return self.stringHolder.length;
 }
@@ -34,4 +40,4 @@ - (void *) _fastCharacterContents {
   return nil;
 }
 
-@end
+@end

branches/tensorflow/tools/swift-api-digester/ModuleAnalyzerNodes.cpp

@@ -1553,6 +1553,8 @@ SwiftDeclCollector::addMembersToRoot(SDKNode *Root, IterableDeclContext *Context
       // All containing variables should have been handled.
     } else if (isa<DestructorDecl>(Member)) {
       // deinit has no impact.
+    } else if (isa<MissingMemberDecl>(Member)) {
+      // avoid adding MissingMemberDecl
     } else {
       llvm_unreachable("unhandled member decl kind.");
     }

branches/tensorflow/utils/api_checker/swift-api-checker.py

@@ -34,7 +34,7 @@ def check_call(cmd, cwd=None, env=os.environ, verbose=False, output=None):
     if verbose:
         print(' '.join([escapeCmdArg(arg) for arg in cmd]))
     return subprocess.check_call(cmd, cwd=cwd, env=env,
-                                 stderr=subprocess.STDOUT, stdout=output)
+                                 stderr=None, stdout=output)
 
 
 def check_output(cmd, verbose=False):