Fix post-merge compiler crashes.

- Remove Swift 3 sema logic for `AdjointExpr`.
- Remove duplicate definitions of `FloatTy` and `DoubleTy` from `IRGenModule`.
- Rename `remapValue to `getMappedValue`.
- Use new `print(ASTPrinter, PrintOptions)` API for differential operator.

Author: dan-zheng

lib/IRGen/IRGenModule.h

@@ -559,9 +559,6 @@ class IRGenModule {
     llvm::PointerType *RelativeAddressPtrTy;
   };
   llvm::IntegerType *Int64Ty;          /// i64
-  // SWIFT_ENABLE_TENSORFLOW
-  llvm::Type *DoubleTy;                /// double
-  llvm::Type *FloatTy;                 /// float
 
   union {
     llvm::IntegerType *SizeTy;         /// usually i32 or i64

lib/SILOptimizer/Mandatory/TFCanonicalizeCFG.cpp

@@ -405,7 +405,7 @@ class BasicBlockCloner : public SILClonerWithScopes<BasicBlockCloner> {
     return bb;
   }
 
-  SILValue remapValue(SILValue Value) {
+  SILValue getMappedValue(SILValue Value) {
     auto VI = ValueMap.find(Value);
     if (VI != ValueMap.end())
       return VI->second;
@@ -1550,7 +1550,7 @@ void SingleExitLoopTransformer::unrollLoopBodyOnce() {
           // A suitable value is found. Update the edge value in the unrolled
           // loop with the corresponding cloned value.
           changeEdgeValue(clonedPred->getTerminator(), clonedNewLatch, argIndex,
-                          cloner.remapValue(value));
+                          cloner.getMappedValue(value));
           patched = true;
           break;
         }

lib/SILOptimizer/Mandatory/TFCanonicalizeCFG.h

@@ -20,6 +20,7 @@
 #define SWIFT_SILOPTIMIZER_TFCANONICALIZECFG_H
 
 #include "swift/SIL/SILBasicBlock.h"
+#include "swift/SIL/BasicBlockUtils.h"
 #include "swift/SIL/LoopInfo.h"
 
 namespace swift {

lib/SILOptimizer/Mandatory/TFDevicePartition.cpp

@@ -190,7 +190,7 @@ class DevicePartitionCloner
       auto *newOperand = cloneSingleInst(cast<SingleValueInstruction>(operand));
       ValueMap[operand] = newOperand;
     }
-    return this->remapValue(operand);
+    return this->getMappedValue(operand);
   }
 };
 }  // end anonymous namespace
@@ -220,7 +220,7 @@ void DevicePartitionCloner::visitGraphOperationInst(GraphOperationInst *inst) {
     auto opValue = inst->getOperand(i);
     assert(isTensorFlowValue(opValue->getType()) &&
            "ops should only use tensors");
-    args.push_back(remapValue(opValue));
+    args.push_back(getMappedValue(opValue));
   }
 
   SmallVector<SILType, 2> resultTypes;
@@ -259,7 +259,7 @@ void DevicePartitionCloner::addD2DSend(GraphOperationInfo &graphOpInfo,
       {ctx.getIdentifier(TF_DEVICE_ATTR),
        SymbolicValue::getString(getDeviceString(thisDeviceType), allocator)});
 
-  auto valueToSend = remapValue(inst->getOperand(0));
+  auto valueToSend = getMappedValue(inst->getOperand(0));
   newInstBuilder.addArgument(valueToSend);
   if (inst->getNumAttributes() > tensorShapeAttrIdx)
     newInstBuilder.addAttribute(inst->getAttribute(tensorShapeAttrIdx));
@@ -342,7 +342,7 @@ void DevicePartitionCloner::visitTensorTransferInst(
   for (auto destDeviceForSend : deviceInfo.getUsedDeviceTypes()) {
     if (destDeviceForSend == srcDevice) {
       // When dest is src, update the mapping, and do not send.
-      ValueMap[getSingleValueResult(inst)] = remapValue(inst->getOperand(0));
+      ValueMap[getSingleValueResult(inst)] = getMappedValue(inst->getOperand(0));
       continue;
     }
     addD2DSend(graphOpInfo, tensorShapeAttrIdx, transferId, destDeviceForSend);

lib/SILOptimizer/Mandatory/TFDifferentiation.cpp

@@ -22,6 +22,7 @@
 #define DEBUG_TYPE "differentiation"
 
 #include "swift/AST/ASTMangler.h"
+#include "swift/AST/ASTPrinter.h"
 #include "swift/AST/AutoDiff.h"
 #include "swift/AST/Builtins.h"
 #include "swift/AST/DeclContext.h"
@@ -767,11 +768,14 @@ void DifferentiationInvoker::print(llvm::raw_ostream &os) const {
        << ") task=" << indDiff.second << ')';
     break;
   }
-  case Kind::DifferentialOperator:
+  case Kind::DifferentialOperator: {
+    StreamPrinter printer(os);
+    PrintOptions options;
     os << "differential_operator=(";
-    getDifferentialOperator()->print(os);
+    getDifferentialOperator()->print(printer, options);
     os << ')';
     break;
+  }
   case Kind::DifferentiableAttribute: {
     auto diffAttr = getDifferentiableAttribute();
     os << "differentiable_attribute=(attr=(";
@@ -3379,7 +3383,7 @@ class AdjointEmitter final : public SILInstructionVisitor<AdjointEmitter> {
   }
 
   /// Remap a value in the original function.
-  SILValue remapValue(SILValue value) {
+  SILValue getMappedValue(SILValue value) {
     // If `value` is a checkpointed primal value, extract it from the primal
     // value aggregate.
     if (auto extractedPV = extractPrimalValueIfAny(value))
@@ -3388,7 +3392,7 @@ class AdjointEmitter final : public SILInstructionVisitor<AdjointEmitter> {
     // rematerialize it in the adjoint function.
     if (auto *inst = value->getDefiningInstruction())
       rematerializeOriginalInstruction(inst);
-    return rematCloner.remapValue(value);
+    return rematCloner.getMappedValue(value);
   }
 
   /// Handle `apply` instruction. If it's active (on the differentiation path),
@@ -3434,7 +3438,7 @@ class AdjointEmitter final : public SILInstructionVisitor<AdjointEmitter> {
     auto originalParamsWithoutSelf = ai->hasSelfArgument() ?
         originalParams.slice(0, originalParams.size() - 1) : originalParams;
     for (auto param : originalParamsWithoutSelf)
-      args.push_back(remapValue(param));
+      args.push_back(getMappedValue(param));
 
     // Add nested primal values.
     if (auto nestedPrimValAggr = extractPrimalValueIfAny(ai, /*nested*/ true)) {
@@ -3443,7 +3447,7 @@ class AdjointEmitter final : public SILInstructionVisitor<AdjointEmitter> {
       args.append(nestedPrimVals.begin(), nestedPrimVals.end());
     }
     // Add original results.
-    auto origResultAggr = remapValue(ai);
+    auto origResultAggr = getMappedValue(ai);
     SmallVector<SILValue, 8> origResults;
     extractAllElements(origResultAggr, builder, origResults);
     args.append(origResults.begin(), origResults.end());
@@ -3466,7 +3470,7 @@ class AdjointEmitter final : public SILInstructionVisitor<AdjointEmitter> {
 
     // Push the mapped self parameter, if any.
     if (ai->hasSelfArgument())
-      args.push_back(remapValue(ai->getSelfArgument()));
+      args.push_back(getMappedValue(ai->getSelfArgument()));
 
     // Call the adjoint function.
     auto *adjointRef = getBuilder().createFunctionRef(ai->getLoc(), adjoint);
@@ -3677,18 +3681,18 @@ class AdjointEmitter final : public SILInstructionVisitor<AdjointEmitter> {
       auto adjVal = materializeAdjointDirect(adj, opLoc);
       auto *adjLHS = builder.createBuiltinBinaryFunction(
           opLoc, "fmul", opType, opType,
-          {adjVal, remapValue(bi->getOperand(1))});
+          {adjVal, getMappedValue(bi->getOperand(1))});
       addAdjointValue(bi->getOperand(0), adjLHS);
       auto *adjRHS = builder.createBuiltinBinaryFunction(
           opLoc, "fmul", opType, opType,
-          {adjVal, remapValue(bi->getOperand(0))});
+          {adjVal, getMappedValue(bi->getOperand(0))});
       addAdjointValue(bi->getOperand(1), adjRHS);
       break;
     }
     case BuiltinValueKind::FDiv: {
       auto adjVal = materializeAdjointDirect(adj, opLoc);
-      auto lhs = remapValue(bi->getOperand(0));
-      auto rhs = remapValue(bi->getOperand(1));
+      auto lhs = getMappedValue(bi->getOperand(0));
+      auto rhs = getMappedValue(bi->getOperand(1));
       // x' = seed / y
       auto adjLHS = builder.createBuiltinBinaryFunction(opLoc, "fdiv", opType,
                                                         opType, {adjVal, rhs});
@@ -3731,7 +3735,7 @@ void AdjointEmitter::rematerializeOriginalInstruction(SILInstruction *inst) {
                          });
   // Ensure that all operands have a corresponding value in the adjoint.
   for (auto &op : inst->getAllOperands())
-    remapValue(op.get());
+    getMappedValue(op.get());
   rematCloner.setInsertionPointBeforeAnyTerminator(ncd);
   rematCloner.visit(inst);
 }

lib/SILOptimizer/Mandatory/TFPartition.cpp

@@ -2354,7 +2354,7 @@ void PartitionCloner::visitBranchInst(BranchInst *inst) {
   unsigned opNum = 0;
   for (auto &arg : inst->getAllOperands()) {
     if (shouldCloneArgument(destBB->getArgument(opNum++)))
-      operands.push_back(remapValue(arg.get()));
+      operands.push_back(getMappedValue(arg.get()));
   }
 
   getBuilder().setCurrentDebugScope(getOpScope(inst->getDebugScope()));
@@ -2409,7 +2409,7 @@ void PartitionCloner::visitGraphOperationInst(GraphOperationInst *inst) {
     //
     // For this special op, we ignore any device placement. Logically, this
     // means this op is always placed on ALL devices.
-    auto result = remapValue(inst->getOperand(0));
+    auto result = getMappedValue(inst->getOperand(0));
     auto S2TResult = inst->getResult(0);
     if (!S2TResult->getType().getASTType()->isEqual(
             result->getType().getASTType())) {
@@ -2474,7 +2474,7 @@ void PartitionCloner::visitScalarInst(SingleValueInstruction *inst) {
   // The TensorToScalar operation is promoted by just dropping the operation
   // and using the incoming tensor value.
   if (opKind == PromotedScalarKind::TensorToScalar) {
-    ValueMap[inst] = remapValue(inst->getOperand(1));
+    ValueMap[inst] = getMappedValue(inst->getOperand(1));
     return;
   }
 
@@ -2489,7 +2489,7 @@ void PartitionCloner::visitScalarInst(SingleValueInstruction *inst) {
     operandRange = operandRange.drop_back();
 
   for (auto &op : operandRange)
-    opBuilder.addArgument(remapValue(op.get()));
+    opBuilder.addArgument(getMappedValue(op.get()));
 
   // The type of the new builtin is usually the same as the input type, but
   // "remapped", which turns Float into TensorHandle<Float>.
@@ -2568,7 +2568,7 @@ void PartitionCloner::visitTupleExtractInst(TupleExtractInst *inst) {
   if (classifyInst(inst->getOperand()->getDefiningInstruction()) ==
       PartitioningClass::OverflowCheckingInst) {
     assert(inst->getFieldNo() == 0 && "Unexpected extract to remap");
-    ValueMap[inst] = remapValue(inst->getOperand());
+    ValueMap[inst] = getMappedValue(inst->getOperand());
     return;
   }
 
@@ -2582,7 +2582,7 @@ void PartitionCloner::visitTupleExtractInst(TupleExtractInst *inst) {
 /// a struct_extract is when this is safe.
 void PartitionCloner::visitStructExtractInst(StructExtractInst *inst) {
   assert(inst->getFieldNo() == 0 && "Unexpected extract to remap");
-  ValueMap[inst] = remapValue(inst->getOperand());
+  ValueMap[inst] = getMappedValue(inst->getOperand());
 }
 
 /// Wrap a value in a simple struct wrapper, these are common in the standard
@@ -3189,7 +3189,7 @@ bool PartitionCloner::insertAccelToHostTransfer(SILValue value, SILLocation loc)
 
   // Create the send in the accelerator code.  Each send/receive pair gets
   // a unique ID to associate one with the other.
-  createAcceleratorSend(BA, loc, remapValue(value), nextSendID, FP.deviceInfo);
+  createAcceleratorSend(BA, loc, getMappedValue(value), nextSendID, FP.deviceInfo);
 
   // Create the receive in the host code.
   auto newVal = createHostReceive(BH, loc, value->getType(), tensorComputation,
@@ -3319,11 +3319,11 @@ void PartitionCloner::cloneFunction(ArrayRef<SILValue> resultValues) {
     // Create a return of N values, producing a tuple if necessary.
     SILValue result;
     if (resultValues.size() == 1)
-      result = remapValue(resultValues[0]);
+      result = getMappedValue(resultValues[0]);
     else {
       SmallVector<SILValue, 4> results;
       for (auto r : resultValues)
-        results.push_back(remapValue(r));
+        results.push_back(getMappedValue(r));
 
       result = Builder.createTuple(FP.hostFn.getLocation(), results);
     }

lib/Sema/TypeCheckExpr.cpp

@@ -720,19 +720,6 @@ TypeChecker::lookupFuncDecl(
                                   funcName))
         results = tmp;
     }
-    // Note: static methods are omitted from `TypeChecker.lookupUnqualified` in
-    // Swift 3. The code below is a workaround for resolving them.
-    //
-    // This is necessary because the stdlib is compiled with `-swift-version 3`
-    // for Swift 3 compatibility, and floating point types use the
-    // `@differentiable` attribute with static adjoint methods (such as
-    // `_adjointAdd`).
-    else if (lookupContext->getASTContext().isSwiftVersion3() &&
-             results.empty() && lookupContext->isTypeContext()) {
-      results = lookupMember(lookupContext,
-                             lookupContext->getSelfTypeInContext(),
-                             funcName);
-    }
   }
 
   // Initialize error flags.