Remove dead code for closure-converting tearoffs.

pkg/kernel/lib/transformations/closure/converter.dart

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library kernel.transformations.closure.converter;
 
 import '../../ast.dart'
     show
         Arguments,
         Block,
@@ skipping 22 matching lines @@
         MethodInvocation,
         Name,
         NamedExpression,
         NamedType,
         NullLiteral,
         Procedure,
         ProcedureKind,
         PropertyGet,
         ReturnStatement,
         Statement,
-        StaticGet,
         StaticInvocation,
         ThisExpression,
         Transformer,
         TreeNode,
         TypeParameter,
         TypeParameterType,
         VariableDeclaration,
         VariableGet,
         VariableSet,
         VectorType,
@@ skipping 19 matching lines @@
   final CoreTypes coreTypes;
   final Set<VariableDeclaration> capturedVariables;
   final Map<FunctionNode, Set<TypeParameter>> capturedTypeVariables;
   final Map<FunctionNode, VariableDeclaration> thisAccess;
   final Map<FunctionNode, String> localNames;
 
   /// Records place-holders for cloning contexts. See [visitForStatement].
   final Set<InvalidExpression> contextClonePlaceHolders =
       new Set<InvalidExpression>();
 
-  /// Maps the names of all instance methods that may be torn off (aka
-  /// implicitly closurized) to `${name.name}#get`.
-  final Map<Name, Name> tearOffGetterNames;
-
   final CloneVisitor cloner = new CloneWithoutBody();
 
   /// New members to add to [currentLibrary] after it has been
   /// transformed. These members will not be transformed themselves.
   final List<TreeNode> newLibraryMembers = <TreeNode>[];
 
   /// New members to add to [currentClass] after it has been transformed. These
   /// members will not be transformed themselves.
   final List<Member> newClassMembers = <Member>[];
 
@@ skipping 32 matching lines @@
   ///
   /// In this example, `typeSubstitution[T].parameter == T_` when transforming
   /// the closure in `f`.
   Map<TypeParameter, DartType> typeSubstitution =
       const <TypeParameter, DartType>{};
 
   ClosureConverter(this.coreTypes, ClosureInfo info)
       : this.capturedVariables = info.variables,
         this.capturedTypeVariables = info.typeVariables,
         this.thisAccess = info.thisAccess,
-        this.localNames = info.localNames,
-        this.tearOffGetterNames = info.tearOffGetterNames;
+        this.localNames = info.localNames;
 
   bool get isOuterMostContext {
     return currentFunction == null || currentMemberFunction == currentFunction;
   }
 
   String get currentFileUri {
     if (currentMember is Constructor) return currentClass.fileUri;
     if (currentMember is Field) return (currentMember as Field).fileUri;
     if (currentMember is Procedure) return (currentMember as Procedure).fileUri;
     throw "No file uri for ${currentMember.runtimeType}";
@@ skipping 212 matching lines @@
             .map((VariableDeclaration decl) =>
                 new NamedType(decl.name, decl.type))
             .toList(),
         typeParameters: function.typeParameters,
         requiredParameterCount: function.requiredParameterCount - 1);
 
     return new ClosureCreation(
         closedTopLevelFunction, accessContext, closureType);
   }
 
-  TreeNode visitField(Field node) {
-    currentMember = node;
-    context = new NoContext(this);
-    if (node.isInstanceMember) {
-      Name tearOffName = tearOffGetterNames[node.name];
-      if (tearOffName != null) {
-        // TODO(ahe): If we rewrite setters, we can rename the field to avoid
-        // an indirection in most cases.
-        addFieldForwarder(tearOffName, node);
-      }
-    }
-    node = super.visitField(node);
-    context = null;
-    currentMember = null;
-    return node;
-  }
-
   TreeNode visitProcedure(Procedure node) {
     assert(isEmptyContext);
 
     currentMember = node;
 
-    if (node.isInstanceMember) {
-      Name tearOffName = tearOffGetterNames[node.name];
-      if (tearOffName != null) {
-        if (node.isGetter) {
-          // We rename the getter to avoid an indirection in most cases.
-          Name oldName = node.name;
-          node.name = tearOffName;
-          node.canonicalName?.unbind();
-          addGetterForwarder(oldName, node);
-        } else if (node.kind == ProcedureKind.Method) {
-          addTearOffMethod(tearOffName, node);
-        }
-      }
-    }
-
     FunctionNode function = node.function;
     if (function.body != null) {
       setupContextForFunctionBody(function);
       VariableDeclaration self = thisAccess[currentMemberFunction];
       if (self != null) {
         context.extend(self, new ThisExpression());
       }
       node.transformChildren(this);
       resetContext();
     }
@@ skipping 184 matching lines @@
     }
     return super.visitForInStatement(node);
   }
 
   TreeNode visitThisExpression(ThisExpression node) {
     return isOuterMostContext
         ? node
         : context.lookup(thisAccess[currentMemberFunction]);
   }
 
-  TreeNode visitStaticGet(StaticGet node) {
-    Member target = node.target;
-    if (target is Procedure && target.kind == ProcedureKind.Method) {
-      VariableDeclaration contextVariable = new VariableDeclaration(
-          "#contextParameter",
-          type: const VectorType());
-      Expression expression = getTearOffExpression(
-          null, node.target, contextVariable, new NullLiteral());
-      expression.transformChildren(this);
-      return expression;
-    }
-    return super.visitStaticGet(node);
-  }
-
-  TreeNode visitPropertyGet(PropertyGet node) {
-    Name tearOffName = tearOffGetterNames[node.name];
-    if (tearOffName != null) {
-      MethodInvocation replacement = new MethodInvocation(
-          node.receiver, tearOffName, new Arguments(<Expression>[]));
-      return super.visitMethodInvocation(replacement);
-    }
-    return super.visitPropertyGet(node);
-  }
-
   TreeNode visitCatch(Catch node) {
     VariableDeclaration exception = node.exception;
     VariableDeclaration stackTrace = node.stackTrace;
     if (stackTrace != null && capturedVariables.contains(stackTrace)) {
       Block block = node.body = ensureBlock(node.body);
       block.parent = node;
       node.stackTrace = new VariableDeclaration(null);
       node.stackTrace.parent = node;
       stackTrace.initializer = new VariableGet(node.stackTrace);
       block.statements.insert(0, stackTrace);
       stackTrace.parent = block;
     }
     if (exception != null && capturedVariables.contains(exception)) {
       Block block = node.body = ensureBlock(node.body);
       block.parent = node;
       node.exception = new VariableDeclaration(null);
       node.exception.parent = node;
       exception.initializer = new VariableGet(node.exception);
       block.statements.insert(0, exception);
       exception.parent = block;
     }
     return super.visitCatch(node);
   }
 
   Block ensureBlock(Statement statement) {
     return statement is Block ? statement : new Block(<Statement>[statement]);
   }
 
-  /// Creates a closure that will invoke method [procedure] of [receiver] and
-  /// return an expression that instantiates that closure.
-  Expression getTearOffExpression(
-      VariableDeclaration receiver,
-      Procedure procedure,
-      VariableDeclaration contextVariable,
-      Expression accessContext) {
-    Map<TypeParameter, DartType> substitution = procedure.isInstanceMember
-        // Note: we do not attempt to avoid copying type variables that aren't
-        // used in the signature of [procedure]. It might be more economical to
-        // only copy type variables that are used. However, we assume that
-        // passing type arguments that match the enclosing class' type
-        // variables will be handled most efficiently.
-        ? copyTypeVariables(procedure.enclosingClass.typeParameters)
-        : const <TypeParameter, DartType>{};
-
-    // TODO(29181): remove variable `dynamicSubstitution` and replace its usages
-    // with `substitution`.
-
-    Map<TypeParameter, DartType> dynamicSubstitution =
-        <TypeParameter, DartType>{};
-    for (TypeParameter parameter in substitution.keys) {
-      dynamicSubstitution[parameter] = const DynamicType();
-    }
-    for (TypeParameter parameter in substitution.keys) {
-      if (!isObject(parameter.bound)) {
-        dynamicSubstitution[parameter] =
-            substitute(parameter.bound, dynamicSubstitution);
-      }
-    }
-
-    // Find the closure class for the function. If there isn't one, create it.
-    String closedTopLevelFunctionName =
-        createNameForClosedTopLevelFunction(procedure.function);
-    Procedure closedTopLevelFunction = null;
-    for (TreeNode node in newLibraryMembers) {
-      if (node is Procedure && node.name.name == closedTopLevelFunctionName) {
-        closedTopLevelFunction = node;
-      }
-    }
-    if (closedTopLevelFunction == null) {
-      closedTopLevelFunction = new Procedure(
-          new Name(closedTopLevelFunctionName),
-          ProcedureKind.Method,
-          forwardFunction(
-              procedure, receiver, contextVariable, dynamicSubstitution),
-          isStatic: true,
-          fileUri: currentFileUri);
-      newLibraryMembers.add(closedTopLevelFunction);
-    }
-
-    return new ClosureCreation(
-        closedTopLevelFunction, accessContext, procedure.function.functionType);
-  }
-
   /// Creates a function that has the same signature as `procedure.function`
   /// and which forwards all arguments to `procedure`.
   FunctionNode forwardFunction(
       Procedure procedure,
       VariableDeclaration receiver,
       VariableDeclaration contextVariable,
       Map<TypeParameter, DartType> substitution) {
     CloneVisitor cloner = substitution.isEmpty
         ? this.cloner
         : new CloneWithoutBody(typeSubstitution: substitution);
@@ skipping 78 matching lines @@
     copy.function.body = body;
     copy.function.body.parent = copy.function;
     return copy;
   }
 
   void addGetterForwarder(Name name, Procedure getter) {
     assert(getter.isGetter);
     newClassMembers
         .add(copyWithBody(getter, forwardToThisProperty(getter))..name = name);
   }
-
-  void addTearOffMethod(Name name, Procedure procedure) {
-    // [addTearOffMethod] generates a method along with a context that captures
-    // `this`. The work with contexts is typically done using the data gathered
-    // by a [ClosureInfo] instance. In absence of this information, we need to
-    // create some variables, like `#self` and `#context`, and manipulate
-    // contexts directly in some cases.
-    //
-    // Also, the tear-off method is generated during a visit to the AST node
-    // of the procedure being torn off, so we need to save and restore some
-    // auxiliary variables like `currentMember` and `currentMemberFunction`
-    // and use [saveContext], so that those variables have proper values when
-    // the procedure itself is being transformed.
-    Member oldCurrentMember = currentMember;
-    FunctionNode oldCurrentMemberFunction = currentMemberFunction;
-    try {
-      saveContext(() {
-        Block body = new Block(<Statement>[]);
-        FunctionNode tearOffMethodFunction = new FunctionNode(body);
-        setupContextForFunctionBody(tearOffMethodFunction);
-
-        // We need a variable that refers to `this` to put it into the context.
-        VariableDeclaration self = new VariableDeclaration("#self",
-            type: procedure.enclosingClass.rawType);
-        context.extend(self, new ThisExpression());
-
-        // The `#context` variable is used to access the context in the closed
-        // top-level function that represents the closure and is generated in
-        // [getTearOffExpression].
-        VariableDeclaration contextVariable = new VariableDeclaration(
-            "#contextParameter",
-            type: const VectorType());
-        Context parent = context;
-        context = context.toNestedContext(
-            new VariableAccessor(contextVariable, null, TreeNode.noOffset));
-
-        body.addStatement(new ReturnStatement(getTearOffExpression(
-            self, procedure, contextVariable, parent.expression)));
-
-        Procedure tearOffMethod = new Procedure(
-            name, ProcedureKind.Method, tearOffMethodFunction,
-            fileUri: currentFileUri);
-        newClassMembers.add(tearOffMethod);
-
-        resetContext();
-      });
-    } finally {
-      currentMember = oldCurrentMember;
-      currentMemberFunction = oldCurrentMemberFunction;
-    }
-  }
 }