---

yaml
---
r: 262107
b: refs/heads/tensorflow
c: 146a111
h: refs/heads/master
i:
  262105: cacac72
  262103: bb8659d

Author: rxwei

[refs]

@@ -818,7 +818,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: 041a1fd63b0fdb26a742e44f45aab1f10558df51
+refs/heads/tensorflow: 146a111948a849e1c7bb17ad5505a8e303bc582a
 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/DiagnosticsParse.def

@@ -1254,14 +1254,6 @@ ERROR(expr_typeof_expected_rparen,PointsToFirstBadToken,
 ERROR(expr_dynamictype_deprecated,PointsToFirstBadToken,
       "'.dynamicType' is deprecated. Use 'type(of: ...)' instead", ())
 
-// Adjoint expressions.
-ERROR(expr_adjoint_expected_function_name,PointsToFirstBadToken,
-      "expected function name within '#adjoint` expression", ())
-ERROR(expr_expected_lparen,none,
-      "expected '(' in '%0' expression", (StringRef))
-ERROR(expr_expected_rparen,none,
-      "expected ')' in '%0' expression", (StringRef))
-
 //------------------------------------------------------------------------------
 // MARK: Attribute-parsing diagnostics
 //------------------------------------------------------------------------------

branches/tensorflow/include/swift/AST/DiagnosticsSema.def

@@ -739,25 +739,6 @@ NOTE(object_literal_resolve_import,none,
 // TensorFlow op literal
 ERROR(invalid_tfop,none, "%0", (StringRef))
 
-// '#adjoint(...)' expression for automatic differentiation
-ERROR(adjoint_expr_original_base_type_unresolved,none,
-      "could not resolve base type %0 of original function in #adjoint "
-      "expression", (TypeLoc))
-ERROR(adjoint_expr_original_not_func_decl,none,
-      "#adjoint expression can only be applied to function declarations, but %0"
-      "is not a function declaration", (DeclName))
-ERROR(adjoint_expr_original_func_decl_unresolved,none,
-      "original function declaration could not be resolved", ())
-ERROR(adjoint_expr_original_no_valid_differentiable_attr,none,
-      "the original function %0 does not declare a valid @differentiable "
-      "attribute", (DeclName))
-ERROR(adjoint_expr_original_overload_not_found,none,
-      "could not find original function %0 with valid @differentiable "
-      "attribute in #adjoint expression", (DeclName))
-ERROR(adjoint_expr_ambiguous_original_function_identifier,none,
-      "ambiguous or overloaded original function identifier %0 cannot be used "
-      "in #adjoint expression", (DeclName))
-
 ERROR(use_local_before_declaration,none,
       "use of local variable %0 before its declaration", (DeclName))
 ERROR(unsupported_existential_type,none,

branches/tensorflow/include/swift/AST/Expr.h

@@ -344,11 +344,6 @@ class alignas(8) Expr {
     NumArgLabels : 16
   );
 
-  // SWIFT_ENABLE_TENSORFLOW
-  SWIFT_INLINE_BITFIELD(AdjointExpr, Expr, 2,
-                        FunctionRefKind : 2
-  );
-
   enum { NumCheckedCastKindBits = 4 };
   SWIFT_INLINE_BITFIELD(CheckedCastExpr, Expr, NumCheckedCastKindBits,
     CastKind : NumCheckedCastKindBits
@@ -3833,64 +3828,6 @@ class DynamicTypeExpr : public Expr {
   }
 };
 
-// SWIFT_ENABLE_TENSORFLOW
-/// The `#adjoint(...)` expression returns the declared adjoint of functions
-/// with the `@differentiable(reverse, ...)` attribute.
-class AdjointExpr : public Expr {
-private:
-  SourceLoc Loc, LParenLoc;
-  // The original function name.
-  DeclName OriginalName;
-  DeclNameLoc OriginalNameLoc;
-  // The base type of the original function.
-  // This is non-null only when the original function is not top-level (i.e. it
-  // is an instance/static method).
-  TypeLoc BaseType;
-  // The resolved adjoint function declaration.
-  ConcreteDeclRef AdjointFunction = nullptr;
-  SourceLoc RParenLoc;
-
-  explicit AdjointExpr(SourceLoc loc, SourceLoc lParenLoc,
-                       DeclName originalName, DeclNameLoc originalNameLoc,
-                       TypeLoc baseType, SourceLoc rParenLoc)
-    : Expr(ExprKind::Adjoint, /*Implicit*/ false), Loc(loc),
-      LParenLoc(lParenLoc), OriginalName(originalName),
-      OriginalNameLoc(originalNameLoc), BaseType(baseType),
-      RParenLoc(rParenLoc) {
-    Bits.AdjointExpr.FunctionRefKind =
-      static_cast<unsigned>(FunctionRefKind::Unapplied);
-  }
-
-public:
-  static AdjointExpr *create(ASTContext &ctx, SourceLoc loc,
-                             SourceLoc lParenLoc, DeclName originalName,
-                             DeclNameLoc originalNameLoc, TypeRepr *baseType,
-                             SourceLoc rParenLoc);
-
-  DeclName getOriginalName() const { return OriginalName; }
-  DeclNameLoc getOriginalNameLoc() const { return OriginalNameLoc; }
-  TypeLoc getBaseType() const { return BaseType; }
-
-  ConcreteDeclRef getAdjointFunction() { return AdjointFunction; }
-  void setAdjointFunction(ConcreteDeclRef ref) { AdjointFunction = ref; }
-
-  SourceRange getSourceRange() const { return SourceRange(Loc, RParenLoc); }
-
-  /// Retrieve the kind of function reference.
-  FunctionRefKind getFunctionRefKind() const {
-    return static_cast<FunctionRefKind>(Bits.AdjointExpr.FunctionRefKind);
-  }
-
-  /// Set the kind of function reference.
-  void setFunctionRefKind(FunctionRefKind refKind) {
-    Bits.AdjointExpr.FunctionRefKind = static_cast<unsigned>(refKind);
-  }
-
-  static bool classof(const Expr *E) {
-    return E->getKind() == ExprKind::Adjoint;
-  }
-};
-
 /// An expression referring to an opaque object of a fixed type.
 /// /// Opaque value expressions occur when a particular value within the AST
 /// needs to be re-used without being re-evaluated or for a value that is

branches/tensorflow/include/swift/AST/ExprNodes.def

@@ -192,7 +192,6 @@ EXPR(ObjCSelector, Expr)
 EXPR(KeyPath, Expr)
 UNCHECKED_EXPR(KeyPathDot, Expr)
 // SWIFT_ENABLE_TENSORFLOW
-EXPR(Adjoint, Expr)
 EXPR(PoundAssert, Expr)
 LAST_EXPR(PoundAssert)
 

branches/tensorflow/include/swift/Parse/Parser.h

@@ -1242,9 +1242,6 @@ class Parser {
   ParserResult<Expr> parseExprConfiguration();
   ParserResult<Expr> parseExprStringLiteral();
   ParserResult<Expr> parseExprTypeOf();
-  /// SWIFT_ENABLE_TENSORFLOW
-  ParserResult<Expr> parseExprGradientBody(ExprKind kind);
-  ParserResult<Expr> parseExprAdjoint();
 
   StringRef copyAndStripUnderscores(StringRef text);
 

branches/tensorflow/lib/AST/ASTDumper.cpp

@@ -1863,22 +1863,6 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
 
-  // SWIFT_ENABLE_TENSORFLOW
-  void visitAdjointExpr(AdjointExpr *E) {
-    printCommon(E, "adjoint_expr");
-    PrintWithColorRAII(OS, TypeReprColor) << " base_type='";
-    if (auto *baseRepr = E->getBaseType().getTypeRepr())
-      baseRepr->print(PrintWithColorRAII(OS, TypeReprColor).getOS());
-    else
-      PrintWithColorRAII(OS, TypeReprColor) << "<<NULL>>";
-    PrintWithColorRAII(OS, TypeReprColor) << "'";
-    PrintWithColorRAII(OS, IdentifierColor) << " original_name='"
-      << E->getOriginalName() << "'";
-    PrintWithColorRAII(OS, ExprModifierColor)
-      << " function_ref=" << getFunctionRefKindStr(E->getFunctionRefKind());
-    PrintWithColorRAII(OS, ParenthesisColor) << ')';
-  }
-
   void visitObjectLiteralExpr(ObjectLiteralExpr *E) {
     printCommon(E, "object_literal") 
       << " kind='" << E->getLiteralKindPlainName() << "'";

branches/tensorflow/lib/AST/ASTWalker.cpp

@@ -455,11 +455,6 @@ class Traversal : public ASTVisitor<Traversal, Expr*, Stmt*,
     return E;
   }
 
-  // SWIFT_ENABLE_TENSORFLOW
-  Expr *visitAdjointExpr(AdjointExpr *E) {
-    return E;
-  }
-
   Expr *visitObjectLiteralExpr(ObjectLiteralExpr *E) {
     HANDLE_SEMANTIC_EXPR(E);
 

branches/tensorflow/lib/AST/Expr.cpp

@@ -366,7 +366,6 @@ ConcreteDeclRef Expr::getReferencedDecl() const {
   NO_REFERENCE(KeyPath);
   NO_REFERENCE(KeyPathDot);
   // SWIFT_ENABLE_TENSORFLOW
-  NO_REFERENCE(Adjoint);
   NO_REFERENCE(PoundAssert);
 
 #undef SIMPLE_REFERENCE
@@ -537,8 +536,6 @@ bool Expr::canAppendPostfixExpression(bool appendingPostfixOperator) const {
   case ExprKind::MagicIdentifierLiteral:
   case ExprKind::ObjCSelector:
   case ExprKind::KeyPath:
-  // SWIFT_ENABLE_TENSORFLOW
-  case ExprKind::Adjoint:
     return true;
 
   case ExprKind::ObjectLiteral:
@@ -1170,15 +1167,6 @@ packSingleArgument(ASTContext &ctx, SourceLoc lParenLoc, ArrayRef<Expr *> args,
   return arg;
 }
 
-// SWIFT_ENABLE_TENSORFLOW
-AdjointExpr *
-AdjointExpr::create(ASTContext &ctx, SourceLoc loc, SourceLoc lParenLoc,
-                    DeclName originalName, DeclNameLoc originalNameLoc,
-                    TypeRepr *baseType, SourceLoc rParenLoc) {
-  return new (ctx) AdjointExpr(loc, lParenLoc, originalName, originalNameLoc,
-                               TypeLoc(baseType, Type()), rParenLoc);
-}
-
 ObjectLiteralExpr::ObjectLiteralExpr(SourceLoc PoundLoc, LiteralKind LitKind,
                                      Expr *Arg,
                                      ArrayRef<Identifier> argLabels,

branches/tensorflow/lib/Parse/ParseExpr.cpp

@@ -1697,10 +1697,6 @@ ParserResult<Expr> Parser::parseExprPrimary(Diag<> ID, bool isExprBasic) {
     return parseExprCollection();
 
   // SWIFT_ENABLE_TENSORFLOW
-  case tok::pound_adjoint:
-    return parseExprAdjoint();
-    break;
-
   case tok::pound_assert:
     return parseExprPoundAssert();
     break;
@@ -3520,84 +3516,6 @@ Parser::parsePlatformVersionConstraintSpec() {
 }
 
 // SWIFT_ENABLE_TENSORFLOW
-/// parseQualifiedDeclName
-///
-///   qualified-decl-name:
-///     type-identifier? unqualified-decl-name
-///   type-identifier:
-///     identifier generic-args? ('.' identifier generic-args?)*
-///
-/// Parses an optional base type, followed by a declaration name.
-/// Returns true on error (if function decl name could not be parsed).
-static bool parseQualifiedDeclName(Parser &P, Diag<> nameParseError,
-                                   TypeRepr *&baseType, DeclName &name,
-                                   DeclNameLoc &nameLoc) {
-  // If the current token is an identifier or `Self` or `Any`, then attempt to
-  // parse the base type. Otherwise, base type is null.
-  bool canParseBaseType = false;
-  {
-    Parser::BacktrackingScope backtrack(P);
-    canParseBaseType = P.canParseTypeIdentifier();
-  }
-  if (canParseBaseType)
-    baseType =
-      P.parseTypeIdentifier(/*isParsingQualifiedDeclName*/ true).getPtrOrNull();
-  else
-    baseType = nullptr;
-
-  // If base type was parsed and has at least one component, then there was a
-  // dot before the current token.
-  bool afterDot = false;
-  if (baseType) {
-    if (auto ident = dyn_cast<IdentTypeRepr>(baseType)) {
-      auto components = ident->getComponentRange();
-      afterDot = std::distance(components.begin(), components.end()) > 0;
-    }
-  }
-  name = P.parseUnqualifiedDeclName(afterDot, nameLoc, nameParseError,
-                                    /*allowOperators*/ true,
-                                    /*allowZeroArgCompoundNames*/ true);
-  // The base type is optional, but the final unqualified decl name is not.
-  // If name could not be parsed, return true for error.
-  if (!name) return true;
-  return false;
-}
-
-/// SWIFT_ENABLE_TENSORFLOW
-/// parseExprAdjoint
-///   expr-adjoint: '#adjoint' '(' qualified-decl-name ')'
-ParserResult<Expr> Parser::parseExprAdjoint() {
-  SyntaxParsingContext AdjointContext(SyntaxContext, SyntaxKind::AdjointExpr);
-
-  SourceLoc poundLoc = consumeToken(tok::pound_adjoint);
-  SourceLoc lParenLoc, rParenLoc;
-
-  auto errorAndSkipToEnd = [&]() -> ParserResult<Expr> {
-    skipUntilDeclStmtRBrace(tok::r_paren);
-    rParenLoc = Tok.is(tok::r_paren) ? consumeToken() : PreviousLoc;
-    return makeParserResult<Expr>(new (Context)
-                                  ErrorExpr(SourceRange(poundLoc, rParenLoc)));
-  };
-
-  if (parseToken(tok::l_paren, lParenLoc, diag::expr_expected_lparen,
-                 "#adjoint"))
-    return errorAndSkipToEnd();
-  // Parse original function.
-  TypeRepr *baseType;
-  DeclName originalName;
-  DeclNameLoc originalNameLoc;
-  if (parseQualifiedDeclName(*this, diag::expr_adjoint_expected_function_name,
-                             baseType, originalName, originalNameLoc))
-    return errorAndSkipToEnd();
-  if (parseToken(tok::r_paren, rParenLoc, diag::expr_expected_rparen,
-                 "#adjoint"))
-    return errorAndSkipToEnd();
-  return makeParserResult<Expr>(
-    AdjointExpr::create(Context, poundLoc, lParenLoc, originalName,
-                        originalNameLoc, baseType, rParenLoc));
-}
-
-/// SWIFT_ENABLE_TENSORFLOW
 /// expr-pound-assert:
 ///   '#assert' '(' expr ',' string_literal ')'
 ParserResult<Expr> Parser::parseExprPoundAssert() {

branches/tensorflow/lib/SILGen/SILGenExpr.cpp

@@ -457,8 +457,6 @@ namespace {
     RValue visitAbstractClosureExpr(AbstractClosureExpr *E, SGFContext C);
     RValue visitInterpolatedStringLiteralExpr(InterpolatedStringLiteralExpr *E,
                                               SGFContext C);
-    // SWIFT_ENABLE_TENSORFLOW
-    RValue visitAdjointExpr(AdjointExpr *E, SGFContext C);
     RValue visitObjectLiteralExpr(ObjectLiteralExpr *E, SGFContext C);
     RValue visitEditorPlaceholderExpr(EditorPlaceholderExpr *E, SGFContext C);
     RValue visitObjCSelectorExpr(ObjCSelectorExpr *E, SGFContext C);
@@ -2728,43 +2726,6 @@ visitInterpolatedStringLiteralExpr(InterpolatedStringLiteralExpr *E,
   return visit(E->getSemanticExpr(), C);
 }
 
-// SWIFT_ENABLE_TENSORFLOW
-RValue RValueEmitter::
-visitAdjointExpr(AdjointExpr *E, SGFContext C) {
-  ConcreteDeclRef adjointFunc = E->getAdjointFunction();
-  FuncDecl *adjointDecl = cast<FuncDecl>(adjointFunc.getDecl());
-  SILLocation loc(adjointDecl);
-  SILDeclRef adjointDeclRef(adjointDecl);
-
-  // If adjoint is an instance method, mark as curried.
-  if (adjointDecl->isInstanceMember()) {
-    adjointDeclRef = adjointDeclRef.asCurried();
-  }
-  auto adjointInfo = SGF.getConstantInfo(adjointDeclRef);
-
-  // Convert function ref to thick function type.
-  if (!adjointDecl->isStatic()) {
-    auto resultTy = E->getType()->getCanonicalType();
-    ManagedValue result =
-      SGF.emitClosureValue(loc, adjointDeclRef, resultTy,
-                           adjointFunc.getSubstitutions());
-    return RValue(SGF, loc, resultTy, result);
-  }
-  // Otherwise, apply metatype to static adjoint method.
-  SILValue ref = SGF.emitGlobalFunctionRef(loc, adjointDeclRef, adjointInfo);
-  auto subs = adjointFunc.getSubstitutions();
-  auto baseMeta = adjointInfo.SILFnType->substGenericArgs(SGF.SGM.M, subs)
-    ->getSelfParameter().getType();
-  auto metatype = SGF.B.createMetatype(loc, SGF.getLoweredType(baseMeta));
-  auto partialApplyTy = SGF.B.getPartialApplyResultType(
-    adjointInfo.getSILType(), 1, SGF.getModule(), subs,
-    ParameterConvention::Direct_Guaranteed);
-  auto apply = SGF.B.createPartialApply(loc, ref, ref->getType(),
-    subs, { metatype }, partialApplyTy);
-  ManagedValue adjointValue = SGF.emitManagedRValueWithCleanup(apply);
-  return RValue(SGF, E, adjointValue);
-}
-
 RValue RValueEmitter::
 visitObjectLiteralExpr(ObjectLiteralExpr *E, SGFContext C) {
   // SWIFT_ENABLE_TENSORFLOW

branches/tensorflow/lib/Sema/CSApply.cpp

@@ -2338,35 +2338,6 @@ namespace {
       llvm_unreachable("Unhandled MagicIdentifierLiteralExpr in switch.");
     }
 
-    // SWIFT_ENABLE_TENSORFLOW
-    Expr *visitAdjointExpr(AdjointExpr *expr) {
-      auto locator = cs.getConstraintLocator(expr);
-      auto adjointDeclRef = expr->getAdjointFunction();
-      auto adjointDecl = cast<FuncDecl>(adjointDeclRef.getDecl());
-
-      // If adjoint is within a type context (it is an instance/static method),
-      // use member locator.
-      if (adjointDecl->getInnermostTypeContext())
-        locator = cs.getConstraintLocator(expr, ConstraintLocator::Member);
-
-      // If adjoint has generic signature, calculate substitutions and update
-      // adjoint decl ref with them.
-      SubstitutionMap substitutions;
-      if (auto genSig = adjointDecl->getGenericSignature()) {
-        substitutions = solution.computeSubstitutions(genSig, locator);
-        expr->setAdjointFunction(
-          ConcreteDeclRef(adjointDecl, substitutions));
-      }
-
-      auto selected = solution.getOverloadChoice(locator);
-      auto simplifiedType = simplifyType(selected.openedFullType);
-      // For static methods, return result of curried method.
-      if (adjointDecl->isStatic())
-        simplifiedType = simplifiedType->castTo<AnyFunctionType>()->getResult();
-      cs.setType(expr, simplifiedType);
-      return expr;
-    }
-
     // SWIFT_ENABLE_TENSORFLOW
     Expr *visitTFOp(ObjectLiteralExpr *expr) {
       auto &ctx = cs.TC.Context;