Revert "More functionality in kernel_impact." and "Compute NativeBehavior for foreign functions."

pkg/compiler/lib/src/ssa/kernel_impact.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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart';
 import '../compiler.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../js_backend/backend.dart' show JavaScriptBackend;
 import '../kernel/kernel.dart';
 import '../kernel/kernel_debug.dart';
 import '../kernel/kernel_visitor.dart';
 import '../resolution/registry.dart' show ResolutionWorldImpactBuilder;
 import '../universe/call_structure.dart';
 import '../universe/feature.dart';
 import '../universe/selector.dart';
 import '../universe/use.dart';
 
 import 'kernel_ast_adapter.dart';
 import '../common/resolution.dart';
 
 /// Computes the [ResolutionImpact] for [resolvedAst] through kernel.
 ResolutionImpact build(Compiler compiler, ResolvedAst resolvedAst) {
   AstElement element = resolvedAst.element;
-  return compiler.reporter.withCurrentElement(element.implementation, () {
-    JavaScriptBackend backend = compiler.backend;
-    Kernel kernel = backend.kernelTask.kernel;
-    KernelImpactBuilder builder =
-        new KernelImpactBuilder(resolvedAst, compiler, kernel);
-    if (element.isFunction ||
-        element.isGetter ||
-        element.isSetter ||
-        element.isFactoryConstructor) {
-      ir.Procedure function = kernel.functions[element];
-      if (function == null) {
-        throw "FOUND NULL FUNCTION: $element";
-      } else {
-        return builder.buildProcedure(function);
-      }
-    } else if (element.isGenerativeConstructor) {
-      ir.Constructor constructor = kernel.functions[element];
-      if (constructor == null) {
-        throw "FOUND NULL CONSTRUCTOR: $element";
-      } else {
-        return builder.buildConstructor(constructor);
-      }
-    } else if (element.isField) {
-      ir.Field field = kernel.fields[element];
-      if (field == null) {
-        throw "FOUND NULL FIELD: $element";
-      } else {
-        return builder.buildField(field);
-      }
+  JavaScriptBackend backend = compiler.backend;
+  Kernel kernel = backend.kernelTask.kernel;
+  KernelImpactBuilder builder =
+      new KernelImpactBuilder(resolvedAst, compiler, kernel);
+  if (element.isFunction ||
+      element.isGetter ||
+      element.isSetter ||
+      element.isFactoryConstructor) {
+    ir.Procedure function = kernel.functions[element];
+    if (function == null) {
+      throw "FOUND NULL FUNCTION: $element";
     } else {
-      throw new UnsupportedError("Unsupported element: $element");
+      return builder.buildProcedure(function);
     }
-  });
+  } else if (element.isGenerativeConstructor) {
+    ir.Constructor constructor = kernel.functions[element];
+    if (constructor == null) {
+      throw "FOUND NULL CONSTRUCTOR: $element";
+    } else {
+      return builder.buildConstructor(constructor);
+    }
+  } else if (element.isField) {
+    ir.Field field = kernel.fields[element];
+    if (field == null) {
+      throw "FOUND NULL FIELD: $element";
+    } else {
+      return builder.buildField(field);
+    }
+  } else {
+    throw new UnsupportedError("Unsupported element: $element");
+  }
 }
 
 class KernelImpactBuilder extends ir.Visitor {
   final ResolvedAst resolvedAst;
   final Compiler compiler;
 
   JavaScriptBackend get backend => compiler.backend;
 
   ResolutionWorldImpactBuilder impactBuilder;
   KernelAstAdapter astAdapter;
@@ skipping 28 matching lines @@
       checkType(node.returnType);
     }
     node.positionalParameters.forEach(handleParameter);
     node.namedParameters.forEach(handleParameter);
   }
 
   ResolutionImpact buildField(ir.Field field) {
     checkType(field.type);
     if (field.initializer != null) {
       visitNode(field.initializer);
-      if (!field.isInstanceMember && !field.isConst) {
+      if (!field.isConst) {
         impactBuilder.registerFeature(Feature.LAZY_FIELD);
       }
     } else {
       impactBuilder.registerFeature(Feature.FIELD_WITHOUT_INITIALIZER);
     }
     return impactBuilder;
   }
 
   ResolutionImpact buildConstructor(ir.Constructor constructor) {
     handleSignature(constructor.function, checkReturnType: false);
@@ skipping 165 matching lines @@
       //    main() {
       //      print(new A<int>.regular() is B<int>);
       //      print(new A<String>.redirect() is B<String>);
       //    }
       //
       // To track that B is actually instantiated as B<int> and B<String> we
       // need to follow the type arguments passed to A.regular and A.redirect
       // to B. Currently, we only do this soundly if we register A<int> and
       // A<String> as instantiated. We should instead register that A.T is
       // instantiated as int and String.
-      handleNew(node, node.target, isConst: node.isConst);
+      handleNew(node, node.target);
     } else {
       _visitArguments(node.arguments);
       impactBuilder.registerStaticUse(new StaticUse.staticInvoke(
           target, astAdapter.getCallStructure(node.arguments)));
     }
-    switch (astAdapter.getForeignKind(node)) {
-      case ForeignKind.JS:
-        impactBuilder
-            .registerNativeData(astAdapter.getNativeBehaviorForJsCall(node));
-        break;
-      case ForeignKind.JS_BUILTIN:
-        impactBuilder.registerNativeData(
-            astAdapter.getNativeBehaviorForJsBuiltinCall(node));
-        break;
-      case ForeignKind.JS_EMBEDDED_GLOBAL:
-        impactBuilder.registerNativeData(
-            astAdapter.getNativeBehaviorForJsEmbeddedGlobalCall(node));
-        break;
-      case ForeignKind.JS_INTERCEPTOR_CONSTANT:
-        if (node.arguments.positional.length != 1 ||
-            node.arguments.named.isNotEmpty) {
-          astAdapter.reporter.reportErrorMessage(CURRENT_ELEMENT_SPANNABLE,
-              MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
-        }
-        ir.Node argument = node.arguments.positional.first;
-        if (argument is ir.TypeLiteral && argument.type is ir.InterfaceType) {
-          impactBuilder.registerTypeUse(
-              new TypeUse.instantiation(astAdapter.getDartType(argument.type)));
-        }
-        break;
-      case ForeignKind.NONE:
-        break;
-    }
   }
 
   @override
   void visitStaticGet(ir.StaticGet node) {
     ir.Member target = node.target;
     Element element = astAdapter.getElement(target).declaration;
     if (target is ir.Procedure && target.kind == ir.ProcedureKind.Method) {
       impactBuilder.registerStaticUse(new StaticUse.staticTearOff(element));
     } else {
       impactBuilder.registerStaticUse(new StaticUse.staticGet(element));
     }
   }
 
   @override
   void visitStaticSet(ir.StaticSet node) {
     visitNode(node.value);
     Element element = astAdapter.getElement(node.target).declaration;
     impactBuilder.registerStaticUse(new StaticUse.staticSet(element));
   }
 
-  void handleSuperInvocation(ir.Node target, ir.Node arguments) {
-    Element element = astAdapter.getElement(target).declaration;
-    _visitArguments(arguments);
-    impactBuilder.registerStaticUse(new StaticUse.superInvoke(
-        element, astAdapter.getCallStructure(arguments)));
-  }
-
-  @override
-  void visitDirectMethodInvocation(ir.DirectMethodInvocation node) {
-    handleSuperInvocation(node.target, node.arguments);
-  }
-
-  @override
-  void visitSuperMethodInvocation(ir.SuperMethodInvocation node) {
-    // TODO(johnniwinther): Should we support this or always use the
-    // [MixinFullResolution] transformer?
-    handleSuperInvocation(node.interfaceTarget, node.arguments);
-  }
-
-  void handleSuperGet(ir.Member target) {
-    Element element = astAdapter.getElement(target).declaration;
-    if (target is ir.Procedure && target.kind == ir.ProcedureKind.Method) {
-      impactBuilder.registerStaticUse(new StaticUse.superTearOff(element));
-    } else {
-      impactBuilder.registerStaticUse(new StaticUse.superGet(element));
-    }
-  }
-
-  @override
-  void visitDirectGet(ir.StaticGet node) {
-    handleSuperGet(node.target);
-  }
-
-  @override
-  void visitSuperPropertyGet(ir.SuperPropertyGet node) {
-    handleSuperGet(node.interfaceTarget);
-  }
-
-  void handleSuperSet(ir.Node target, ir.Node value) {
-    visitNode(value);
-    Element element = astAdapter.getElement(target).declaration;
-    if (target is ir.Field) {
-      impactBuilder.registerStaticUse(new StaticUse.superFieldSet(element));
-    } else {
-      impactBuilder.registerStaticUse(new StaticUse.superSetterSet(element));
-    }
-  }
-
-  @override
-  void visitDirectPropertySet(ir.DirectPropertySet node) {
-    handleSuperSet(node.target, node.value);
-  }
-
-  @override
-  void visitSuperPropertySet(ir.SuperPropertySet node) {
-    handleSuperSet(node.interfaceTarget, node.value);
-  }
-
   @override
   void visitMethodInvocation(ir.MethodInvocation invocation) {
     var receiver = invocation.receiver;
     if (receiver is ir.VariableGet &&
         receiver.variable.isFinal &&
         receiver.variable.parent is ir.FunctionDeclaration) {
       // Invocation of a local function. No need for dynamic use.
     } else {
       visitNode(invocation.receiver);
       impactBuilder.registerDynamicUse(
@@ skipping 55 matching lines @@
       visitNode(node.initializer);
     } else {
       impactBuilder.registerFeature(Feature.LOCAL_WITHOUT_INITIALIZER);
     }
   }
 
   @override
   void visitIsExpression(ir.IsExpression node) {
     impactBuilder.registerTypeUse(
         new TypeUse.isCheck(astAdapter.getDartType(node.type)));
-    visitNode(node.operand);
   }
 
   @override
   void visitAsExpression(ir.AsExpression node) {
     impactBuilder
         .registerTypeUse(new TypeUse.asCast(astAdapter.getDartType(node.type)));
-    visitNode(node.operand);
   }
 
   @override
   void visitThrow(ir.Throw node) {
     impactBuilder.registerFeature(Feature.THROW_EXPRESSION);
     visitNode(node.expression);
   }
 
   @override
   void visitForInStatement(ir.ForInStatement node) {
@@ skipping 30 matching lines @@
     }
     visitNode(node.body);
   }
 
   @override
   void visitTryFinally(ir.TryFinally node) {
     visitNode(node.body);
     visitNode(node.finalizer);
   }
 
-  @override
-  void visitTypeLiteral(ir.TypeLiteral node) {
-    impactBuilder.registerTypeUse(
-        new TypeUse.typeLiteral(astAdapter.getDartType(node.type)));
-  }
-
-  @override
-  void visitFieldInitializer(ir.FieldInitializer node) {
-    impactBuilder.registerStaticUse(
-        new StaticUse.fieldInit(astAdapter.getElement(node.field)));
-    visitNode(node.value);
-  }
-
-  @override
-  void visitRedirectingInitializer(ir.RedirectingInitializer node) {
-    _visitArguments(node.arguments);
-    Element target = astAdapter.getElement(node.target).declaration;
-    impactBuilder.registerStaticUse(new StaticUse.superConstructorInvoke(
-        target, astAdapter.getCallStructure(node.arguments)));
-  }
-
   // TODO(johnniwinther): Make this throw and visit child nodes explicitly
   // instead to ensure that we don't visit unwanted parts of the ir.
   @override
   void defaultNode(ir.Node node) => node.visitChildren(this);
 }