---

yaml
---
r: 327159
b: refs/heads/tensorflow
c: f567b8f
h: refs/heads/master
i:
  327157: 5e050e2
  327155: cf53429
  327151: 88e9eda

Author: slavapestov

[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: 771a390c573f1274749897c648fe5d49d160f41b
+refs/heads/tensorflow: f567b8ff422c9dd3cd10343839b4bdadf0f0b428
 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/include/swift/AST/Builtins.def

@@ -418,14 +418,6 @@ BUILTIN_MISC_OPERATION(Strideof, "strideof", "n", Special)
 /// IsPOD has type T.Type -> Bool
 BUILTIN_MISC_OPERATION(IsPOD, "ispod", "n", Special)
 
-/// IsConcrete has type (T.Type) -> Bool
-///
-/// If the meta type T is concrete, we can always transform this to `true` at
-/// any time in SIL. If it's generic, then we lower it to `false` right before
-/// IRGen in IRGenPrepare. This allows for the optimizer to specialize this at
-/// -O and eliminate conditional code.
-BUILTIN_MISC_OPERATION(IsConcrete, "isConcrete", "n", Special)
-
 /// IsBitwiseTakable has type T.Type -> Bool
 BUILTIN_MISC_OPERATION(IsBitwiseTakable, "isbitwisetakable", "n", Special)
 

branches/tensorflow/lib/AST/Builtins.cpp

@@ -737,13 +737,6 @@ static ValueDecl *getIsPODOperation(ASTContext &Context, Identifier Id) {
   return builder.build(Id);
 }
 
-static ValueDecl *getIsConcrete(ASTContext &Context, Identifier Id) {
-  BuiltinGenericSignatureBuilder builder(Context);
-  builder.addParameter(makeMetatype(makeGenericParam()));
-  builder.setResult(makeConcrete(BuiltinIntegerType::get(1,Context)));
-  return builder.build(Id);
-}
-
 static ValueDecl *getIsBitwiseTakable(ASTContext &Context, Identifier Id) {
   BuiltinGenericSignatureBuilder builder(Context);
   builder.addParameter(makeMetatype(makeGenericParam()));
@@ -1864,9 +1857,6 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
   case BuiltinValueKind::IsPOD:
     return getIsPODOperation(Context, Id);
 
-  case BuiltinValueKind::IsConcrete:
-    return getIsConcrete(Context, Id);
-
   case BuiltinValueKind::IsBitwiseTakable:
     return getIsBitwiseTakable(Context, Id);
 

branches/tensorflow/lib/AST/NameLookup.cpp

@@ -261,22 +261,19 @@ static void recordShadowedDeclsAfterSignatureMatch(
           isa<ProtocolDecl>(secondDecl->getDeclContext()))
         continue;
 
-      // Prefer declarations in the current module over those in another
-      // module.
-      // FIXME: This is a hack. We should query a (lazily-built, cached)
-      // module graph to determine shadowing.
-      if ((firstModule == curModule) != (secondModule == curModule)) {
-        // If the first module is the current module, the second declaration
-        // is shadowed by the first.
-        if (firstModule == curModule) {
+      // [Backward compatibility] For members of types, the general module
+      // shadowing check is performed after unavailable candidates have
+      // already been dropped.
+      if (firstModule != secondModule &&
+          !firstDecl->getDeclContext()->isModuleScopeContext() &&
+          !secondDecl->getDeclContext()->isModuleScopeContext()) {
+        if (imports.isShadowedBy(firstModule, secondModule, dc)) {
+          shadowed.insert(firstDecl);
+          break;
+        } else if (imports.isShadowedBy(secondModule, firstModule, dc)) {
           shadowed.insert(secondDecl);
           continue;
         }
-
-        // Otherwise, the first declaration is shadowed by the second. There is
-        // no point in continuing to compare the first declaration to others.
-        shadowed.insert(firstDecl);
-        break;
       }
 
       // Prefer declarations in the any module over those in the standard

branches/tensorflow/lib/IRGen/GenBuiltin.cpp

@@ -179,13 +179,6 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
     return;
   }
 
-  if (Builtin.ID == BuiltinValueKind::IsConcrete) {
-    (void)args.claimAll();
-    auto isConcrete = !substitutions.getReplacementTypes()[0]->hasArchetype();
-    out.add(llvm::ConstantInt::get(IGF.IGM.Int1Ty, isConcrete));
-    return;
-  }
-
   if (Builtin.ID == BuiltinValueKind::IsBitwiseTakable) {
     (void)args.claimAll();
     auto valueTy = getLoweredTypeAndTypeInfo(IGF.IGM,

branches/tensorflow/lib/Parse/ParseType.cpp

@@ -669,19 +669,19 @@ Parser::TypeResult Parser::parseTypeIdentifier() {
       if (startsWithLess(Tok)) {
         SmallVector<TypeRepr *, 4> GenericArgsAST;
         SourceLoc LAngleLoc, RAngleLoc;
-        auto GenericArgsResult = parseGenericArgumentClauseSyntax();
+        auto GenericArgsResult =
+            parseGenericArgumentsAST(GenericArgsAST, LAngleLoc, RAngleLoc);
         if (!GenericArgsResult.isSuccess()) {
           if (Base)
             Junk.push_back(*Base);
           if (Period)
             Junk.push_back(*Period);
           Junk.push_back(*Identifier);
-          auto genericJunks = GenericArgsResult.getUnknownNodes();
-          Junk.append(genericJunks.begin(), genericJunks.end());
-          return makeParsedResult<ParsedTypeSyntax>(
-              Junk, GenericArgsResult.getStatus());
+          if (auto GenericJunk = SyntaxContext->popIf<ParsedSyntax>())
+            Junk.push_back(*GenericJunk);
+          return makeParsedResult<ParsedTypeSyntax>(Junk, GenericArgsResult);
         }
-        GenericArgs = GenericArgsResult.getResult();
+        GenericArgs = SyntaxContext->popIf<ParsedGenericArgumentClauseSyntax>();
       }
 
       if (!Base)
@@ -1074,18 +1074,15 @@ Parser::TypeResult Parser::parseTypeTupleBody() {
       // Consume a name.
       NameLoc = Tok.getLoc();
       Name = consumeArgumentLabelSyntax();
-      LocalJunk.push_back(*Name);
 
       // If there is a second name, consume it as well.
       if (Tok.canBeArgumentLabel()) {
         SecondNameLoc = Tok.getLoc();
         SecondName = consumeArgumentLabelSyntax();
-        LocalJunk.push_back(*SecondName);
       }
 
       // Consume the ':'.
       if ((Colon = consumeTokenSyntaxIf(tok::colon))) {
-        LocalJunk.push_back(*Colon);
         // If we succeed, then we successfully parsed a label.
         if (Backtracking)
           Backtracking->cancelBacktrack();
@@ -1094,6 +1091,8 @@ Parser::TypeResult Parser::parseTypeTupleBody() {
       } else {
         if (!Backtracking)
           diagnose(Tok, diag::expected_parameter_colon);
+        Name = None;
+        SecondName = None;
         NameLoc = SourceLoc();
         SecondNameLoc = SourceLoc();
       }
@@ -1104,14 +1103,20 @@ Parser::TypeResult Parser::parseTypeTupleBody() {
 
     Backtracking.reset();
 
+    if (Name)
+      LocalJunk.push_back(*Name);
+    if (SecondName)
+      LocalJunk.push_back(*SecondName);
+    if (Colon)
+      LocalJunk.push_back(*Colon);
+
     // Parse the type annotation.
     auto TypeLoc = Tok.getLoc();
     auto TypeASTResult = parseType(diag::expected_type);
     if (TypeASTResult.hasCodeCompletion() || TypeASTResult.isNull()) {
-      Junk.append(LocalJunk.begin(), LocalJunk.end());
-      if (auto parsedT = SyntaxContext->popIf<ParsedTypeSyntax>())
-        Junk.push_back(*parsedT);
       skipListUntilDeclRBraceSyntax(Junk, LParenLoc, tok::r_paren, tok::comma);
+      for (auto &&Item : LocalJunk)
+        Junk.push_back(Item);
       return TypeASTResult.hasCodeCompletion()
                  ? makeParserCodeCompletionStatus()
                  : makeParserError();

branches/tensorflow/lib/SIL/OperandOwnership.cpp

@@ -983,7 +983,6 @@ ANY_OWNERSHIP_BUILTIN(IntToFPWithOverflow)
 ANY_OWNERSHIP_BUILTIN(IntToPtr)
 ANY_OWNERSHIP_BUILTIN(IsOptionalType)
 ANY_OWNERSHIP_BUILTIN(IsPOD)
-ANY_OWNERSHIP_BUILTIN(IsConcrete)
 ANY_OWNERSHIP_BUILTIN(IsBitwiseTakable)
 ANY_OWNERSHIP_BUILTIN(IsSameMetatype)
 ANY_OWNERSHIP_BUILTIN(LShr)

branches/tensorflow/lib/SIL/ValueOwnership.cpp

@@ -448,7 +448,6 @@ CONSTANT_OWNERSHIP_BUILTIN(Any, Sizeof)
 CONSTANT_OWNERSHIP_BUILTIN(Any, Strideof)
 CONSTANT_OWNERSHIP_BUILTIN(Any, StringObjectOr)
 CONSTANT_OWNERSHIP_BUILTIN(Any, IsPOD)
-CONSTANT_OWNERSHIP_BUILTIN(Any, IsConcrete)
 CONSTANT_OWNERSHIP_BUILTIN(Any, IsBitwiseTakable)
 CONSTANT_OWNERSHIP_BUILTIN(Any, IsSameMetatype)
 CONSTANT_OWNERSHIP_BUILTIN(Any, Alignof)

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

@@ -340,62 +340,6 @@ bool SemanticARCOptVisitor::performGuaranteedCopyValueOptimization(CopyValueInst
   if (isConsumed(cvi, destroys, &guaranteedForwardingInsts))
     return false;
 
-  // Next check if we have any destroys at all of our copy_value and an operand
-  // that is not a function argument. Otherwise, due to the way we ignore dead
-  // end blocks, we may eliminate the copy_value, creating a use of the borrowed
-  // value after the end_borrow.
-  //
-  // DISCUSSION: Consider the following SIL:
-  //
-  // ```
-  //   %1 = begin_borrow %0 : $KlassPair                            (1)
-  //   %2 = struct_extract %1 : $KlassPair, #KlassPair.firstKlass
-  //   %3 = copy_value %2 : $Klass
-  //   ...
-  //   end_borrow %1 : $LintCommand                                 (2)
-  //   cond_br ..., bb1, bb2
-  //
-  //   ...
-  //
-  //   bbN:
-  //     // Never return type implies dead end block.
-  //     apply %f(%3) : $@convention(thin) (@guaranteed Klass) -> Never (3)
-  //     unreachable
-  // ```
-  //
-  // For simplicity, note that if bbN post-dominates %3, given that when we
-  // compute linear lifetime errors we ignore dead end blocks, we would not
-  // register that the copy_values only use is outside of the begin_borrow
-  // region defined by (1), (2) and thus would eliminate the copy. This would
-  // result in %2 being used by %f, causing the linear lifetime checker to
-  // error.
-  //
-  // Naively one may assume that the solution to this is to just check if %3 has
-  // /any/ destroy_values at all and if it doesn't have any reachable
-  // destroy_values, then we are in this case. But is this correct in
-  // general. We prove this below:
-  //
-  // The only paths along which the copy_value can not be destroyed or consumed
-  // is along paths to dead end blocks. Trivially, we know that such a dead end
-  // block, can not be reachable from the end_borrow since by their nature dead
-  // end blocks end in unreachables.
-  //
-  // So we know that we can only run into this bug if we have a dead end block
-  // reachable from the end_borrow, meaning that the bug can not occur if we
-  // branch before the end_borrow since in that case, the borrow scope would
-  // last over the dead end block's no return meaning that we will not use the
-  // borrowed value after its lifetime is ended by the end_borrow.
-  //
-  // With that in hand, we note again that if we have exactly one consumed,
-  // destroy_value /after/ the end_borrow we will not optimize here. This means
-  // that this bug can only occur if the copy_value is only post-dominated by
-  // dead end blocks that use the value in a non-consuming way.
-  if (destroys.empty() && llvm::any_of(borrowIntroducers, [](SILValue v) {
-        return !isa<SILFunctionArgument>(v);
-      })) {
-    return false;
-  }
-
   // If we reached this point, then we know that all of our users can
   // accept a guaranteed value and our owned value is destroyed only
   // by destroy_value. Check if all of our destroys are joint

branches/tensorflow/lib/SILOptimizer/SILCombiner/SILCombiner.h

@@ -285,9 +285,6 @@ class SILCombiner :
   /// Instruction visitor helpers.
   SILInstruction *optimizeBuiltinCanBeObjCClass(BuiltinInst *AI);
 
-  // Optimize the "isConcrete" builtin.
-  SILInstruction *optimizeBuiltinIsConcrete(BuiltinInst *I);
-
   // Optimize the "trunc_N1_M2" builtin. if N1 is a result of "zext_M1_*" and
   // the following holds true: N1 > M1 and M2>= M1
   SILInstruction *optimizeBuiltinTruncOrBitCast(BuiltinInst *I);

branches/tensorflow/lib/SILOptimizer/SILCombiner/SILCombinerBuiltinVisitors.cpp

@@ -102,13 +102,6 @@ SILInstruction *SILCombiner::optimizeBuiltinCanBeObjCClass(BuiltinInst *BI) {
   llvm_unreachable("Unhandled TypeTraitResult in switch.");
 }
 
-SILInstruction *SILCombiner::optimizeBuiltinIsConcrete(BuiltinInst *BI) {
-  if (BI->getOperand(0)->getType().hasArchetype())
-    return nullptr;
-
-  return Builder.createIntegerLiteral(BI->getLoc(), BI->getType(), 1);
-}
-
 static unsigned getTypeWidth(SILType Ty) {
   if (auto BuiltinIntTy = Ty.getAs<BuiltinIntegerType>()) {
     if (BuiltinIntTy->isFixedWidth()) {
@@ -532,8 +525,6 @@ SILInstruction *SILCombiner::optimizeStringObject(BuiltinInst *BI) {
 SILInstruction *SILCombiner::visitBuiltinInst(BuiltinInst *I) {
   if (I->getBuiltinInfo().ID == BuiltinValueKind::CanBeObjCClass)
     return optimizeBuiltinCanBeObjCClass(I);
-  if (I->getBuiltinInfo().ID == BuiltinValueKind::IsConcrete)
-    return optimizeBuiltinIsConcrete(I);
   if (I->getBuiltinInfo().ID == BuiltinValueKind::TakeArrayFrontToBack ||
       I->getBuiltinInfo().ID == BuiltinValueKind::TakeArrayBackToFront ||
       I->getBuiltinInfo().ID == BuiltinValueKind::TakeArrayNoAlias ||

branches/tensorflow/lib/SILOptimizer/Transforms/AccessEnforcementReleaseSinking.cpp

@@ -109,7 +109,6 @@ static bool isBarrier(SILInstruction *inst) {
     case BuiltinValueKind::Sizeof:
     case BuiltinValueKind::Strideof:
     case BuiltinValueKind::IsPOD:
-    case BuiltinValueKind::IsConcrete:
     case BuiltinValueKind::IsBitwiseTakable:
     case BuiltinValueKind::IsSameMetatype:
     case BuiltinValueKind::Alignof:

branches/tensorflow/lib/SILOptimizer/Utils/ConstantFolding.cpp

@@ -1166,18 +1166,6 @@ static SILValue foldFPTrunc(BuiltinInst *BI, const BuiltinInfo &Builtin,
   return B.createFloatLiteral(Loc, BI->getType(), truncVal);
 }
 
-static SILValue constantFoldIsConcrete(BuiltinInst *BI) {
-  if (BI->getOperand(0)->getType().hasArchetype()) {
-    return SILValue();
-  }
-  SILBuilderWithScope builder(BI);
-  auto *inst = builder.createIntegerLiteral(
-      BI->getLoc(), SILType::getBuiltinIntegerType(1, builder.getASTContext()),
-      true);
-  BI->replaceAllUsesWith(inst);
-  return inst;
-}
-
 static SILValue constantFoldBuiltin(BuiltinInst *BI,
                                     Optional<bool> &ResultsInError) {
   const IntrinsicInfo &Intrinsic = BI->getIntrinsicInfo();
@@ -1575,8 +1563,7 @@ void ConstantFolder::initializeWorklist(SILFunction &f) {
         continue;
       }
 
-      if (isApplyOfBuiltin(*inst, BuiltinValueKind::GlobalStringTablePointer) ||
-          isApplyOfBuiltin(*inst, BuiltinValueKind::IsConcrete)) {
+      if (isApplyOfBuiltin(*inst, BuiltinValueKind::GlobalStringTablePointer)) {
         WorkList.insert(inst);
         continue;
       }
@@ -1794,17 +1781,6 @@ ConstantFolder::processWorkList() {
       continue;
     }
 
-    if (isApplyOfBuiltin(*I, BuiltinValueKind::IsConcrete)) {
-      if (constantFoldIsConcrete(cast<BuiltinInst>(I))) {
-        // Here, the bulitin instruction got folded, so clean it up.
-        recursivelyDeleteTriviallyDeadInstructions(
-            I, /*force*/ true,
-            [&](SILInstruction *DeadI) { WorkList.remove(DeadI); });
-        InvalidateInstructions = true;
-      }
-      continue;
-    }
-
     // Go through all users of the constant and try to fold them.
     FoldedUsers.clear();
     for (auto Result : I->getResults()) {

branches/tensorflow/lib/Sema/TypeCheckStorage.cpp

@@ -412,6 +412,14 @@ static void addMemberToContextIfNeeded(Decl *D, DeclContext *DC,
   }
 }
 
+static ParamDecl *getParamDeclAtIndex(FuncDecl *fn, unsigned index) {
+  return fn->getParameters()->get(index);
+}
+
+static VarDecl *getFirstParamDecl(FuncDecl *fn) {
+  return getParamDeclAtIndex(fn, 0);
+};
+
 /// Build a parameter list which can forward the formal index parameters of a
 /// declaration.
 ///
@@ -1299,7 +1307,7 @@ synthesizeTrivialSetterBodyWithStorage(AccessorDecl *setter,
                                        ASTContext &ctx) {
   SourceLoc loc = setter->getStorage()->getLoc();
 
-  VarDecl *valueParamDecl = setter->getParameters()->get(0);
+  VarDecl *valueParamDecl = getFirstParamDecl(setter);
 
   auto *valueDRE =
     new (ctx) DeclRefExpr(valueParamDecl, DeclNameLoc(), /*IsImplicit=*/true);

branches/tensorflow/stdlib/public/core/Builtin.swift

@@ -691,19 +691,6 @@ func _isPOD<T>(_ type: T.Type) -> Bool {
   return Bool(Builtin.ispod(type))
 }
 
-/// Returns `true` if `type` is known to refer to a concrete type once all
-/// optimizations and constant folding has occurred at the call site. Otherwise,
-/// this returns `false` if the check has failed.
-///
-/// Note that there may be cases in which, despite `T` being concrete at some
-/// point in the caller chain, this function will return `false`.
-@_alwaysEmitIntoClient
-@_transparent
-public // @testable
-func _isConcrete<T>(_ type: T.Type) -> Bool {
-  return Bool(Builtin.isConcrete(type))
-}
-
 /// Returns `true` if type is a bitwise takable. A bitwise takable type can
 /// just be moved to a different address in memory.
 @_transparent