Move computation of method flags into model.

pkg/compiler/lib/src/js_emitter/program_builder.dart

 // Copyright (c) 2014, 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 dart2js.js_emitter.program_builder;
 
 import 'js_emitter.dart' show computeMixinClass;
 import 'model.dart';
 
 import '../common.dart';
@@ skipping 248 matching lines @@
     List<Field> staticFieldsForReflection = _buildFields(library, visitStatics);
 
     return new Library(library, uri, statics, classes,
                        staticFieldsForReflection);
   }
 
   /// HACK for Try.
   ///
   /// Returns a class that contains the fields of a class.
   Class buildClassWithFieldsForTry(ClassElement element) {
+    assert(_compiler.hasIncrementalSupport);
     bool onlyForRti = _task.typeTestRegistry.rtiNeededClasses.contains(element);
 
     List<Field> instanceFields =
         onlyForRti ? const <Field>[] : _buildFields(element, false);
 
     String name = namer.getNameOfClass(element);
     String holderName = namer.globalObjectFor(element);
     Holder holder = _registry.registerHolder(holderName);
     bool isInstantiated =
         _compiler.codegenWorld.directlyInstantiatedClasses.contains(element);
@@ skipping 88 matching lines @@
                          isChecks,
                          typeTests.functionTypeIndex,
                          isDirectlyInstantiated: isInstantiated,
                          onlyForRti: onlyForRti,
                          isNative: element.isNative);
     }
     _classes[element] = result;
     return result;
   }
 
-  Method _buildMethod(FunctionElement element, js.Expression code) {
+  bool _methodNeedsStubs(FunctionElement method) {
+    return !method.functionSignature.optionalParameters.isEmpty;
+  }
+
+  bool _methodCanBeReflected(FunctionElement method) {
+    return backend.isAccessibleByReflection(method) ||
+        // During incremental compilation, we have to assume that reflection
+        // *might* get enabled.
+        _compiler.hasIncrementalSupport;
+  }
+
+  bool _methodCanBeApplied(FunctionElement method) {
+    return _compiler.enabledFunctionApply &&
+        _compiler.world.getMightBePassedToApply(method);
+  }
+
+  // Hack for Try!
+  Method buildMethodForTry(FunctionElement element) {

[floitsch, 2015/01/28 16:10:39]

As discussed: change name.

[herhut, 2015/01/29 10:24:21]

now buildMethodHackForIncrementalCompilation

+    assert(_compiler.hasIncrementalSupport);
+    if (element.isInstanceMember) {
+      js.Expression code = backend.generatedCode[element];
+      return _buildMethod(element, code);
+    } else {
+      return _buildStaticMethod(element);
+    }
+  }
+
+  // TODO(herhut): Why does this get code passed in and statics don't?

[floitsch, 2015/01/28 16:10:39]

Probably just an oversight.

[herhut, 2015/01/29 10:24:21]

Changed.

+  DartMethod _buildMethod(FunctionElement element, js.Expression code) {
     String name = namer.getNameOfInstanceMember(element);
-    // TODO(floitsch): compute `needsTearOff`.
-    return new Method(element, name, code, needsTearOff: false);
+
+    bool canTearOff = false;
+    String tearOffName;
+    bool isClosure = false;
+    bool isNotApplyTarget = !element.isFunction || element.isAccessor;
+
+    final bool needsStubs = _methodNeedsStubs(element);
+    final bool canBeReflected = _methodCanBeReflected(element);
+    final bool canBeApplied = _methodCanBeApplied(element);
+    final bool hasSuperAlias = backend.isAliasedSuperMember(element);
+
+    if (isNotApplyTarget) {
+      canTearOff = false;
+    } else {
+      if (element.enclosingClass.isClosure) {
+        canTearOff = false;
+        isClosure = true;
+      } else {
+        // Careful with operators.
+        canTearOff = universe.hasInvokedGetter(element, _compiler.world) ||
+            (canBeReflected && !element.isOperator);
+        assert(canTearOff ||
+               !universe.methodsNeedingSuperGetter.contains(element));
+        tearOffName = namer.getterName(element);
+      }
+    }
+
+    if (canTearOff) {
+      assert(invariant(element, !element.isGenerativeConstructor));
+      assert(invariant(element, !element.isGenerativeConstructorBody));
+      assert(invariant(element, !element.isConstructor));
+    }
+
+    return new InstanceMethod(element, name, code, needsTearOff: canTearOff,
+        tearOffName: tearOffName, isClosure: isClosure,
+        hasSuperAlias: hasSuperAlias, canBeApplied: canBeApplied,
+        canBeReflected: canBeReflected, needsStubs: needsStubs);
   }
 
   /// Builds a stub method.
   ///
   /// Stub methods may have an element that can be used for code-size
   /// attribution.
   Method _buildStubMethod(String name, js.Expression code,
                           {Element element}) {
-    // TODO(floitsch): compute `needsTearOff`.
-    return new StubMethod(name, code, needsTearOff: false, element: element);
+    return new StubMethod(name, code, element: element);
   }
 
   // The getInterceptor methods directly access the prototype of classes.
   // We must evaluate these classes eagerly so that the prototype is
   // accessible.
   void _markEagerInterceptorClasses() {
     Map<String, Set<ClassElement>> specializedGetInterceptors =
         backend.specializedGetInterceptors;
     for (Set<ClassElement> classes in specializedGetInterceptors.values) {
       for (ClassElement element in classes) {
@@ skipping 10 matching lines @@
     String holderName = namer.globalObjectFor(backend.interceptorsLibrary);
     Holder holder = _registry.registerHolder(holderName);
 
     Map<String, Set<ClassElement>> specializedGetInterceptors =
         backend.specializedGetInterceptors;
     List<String> names = specializedGetInterceptors.keys.toList()..sort();
     return names.map((String name) {
       Set<ClassElement> classes = specializedGetInterceptors[name];
       js.Expression code = stubGenerator.generateGetInterceptorMethod(classes);
       // TODO(floitsch): compute `needsTearOff`.
+      // TODO(herhut): Can these actually ever be torn off?

[floitsch, 2015/01/28 16:10:39]

Until we find a case where it can be, let's just remove it and assume that "no".

[herhut, 2015/01/29 10:24:21]

Done.

       return new StaticStubMethod(name, holder, code, needsTearOff: false);
     });
   }
 
   List<Field> _buildFields(Element holder, bool visitStatics) {
     List<Field> fields = <Field>[];
     _task.oldEmitter.classEmitter.visitFields(
         holder, visitStatics, (VariableElement field,
                                String name,
                                String accessorName,
@@ skipping 48 matching lines @@
     return names.map((String name) {
       js.Expression code = stubGenerator.generateOneShotInterceptor(name);
       return new StaticStubMethod(name, holder, code, needsTearOff: false);
     });
   }
 
   StaticMethod _buildStaticMethod(FunctionElement element) {
     String name = namer.getNameOfMember(element);
     String holder = namer.globalObjectFor(element);
     js.Expression code = backend.generatedCode[element];
-    bool needsTearOff =
-        universe.staticFunctionsNeedingGetter.contains(element);
-    // TODO(floitsch): add tear-off name: namer.getStaticClosureName(element).
+
+    final bool isNotApplyTarget = !element.isConstructor && !element.isAccessor;
+    final bool needsStubs = _methodNeedsStubs(element);
+    final bool canBeApplied = _methodCanBeApplied(element);
+    final bool canBeReflected = _methodCanBeReflected(element);
+
+    final bool needsTearOff = isNotApplyTarget && (canBeReflected ||
+         universe.staticFunctionsNeedingGetter.contains(element));
+
+    final String tearOffName =
+        needsTearOff ? namer.getStaticClosureName(element) : null;
+
     return new StaticMethod(element,
                             name, _registry.registerHolder(holder), code,
-                            needsTearOff: needsTearOff);
+                            needsTearOff: needsTearOff,
+                            tearOffName: tearOffName,
+                            canBeApplied: canBeApplied,
+                            canBeReflected: canBeReflected,
+                            needsStubs: needsStubs);
   }
 
   void _registerConstants(OutputUnit outputUnit,
                           Iterable<ConstantValue> constantValues) {
     // `constantValues` is null if an outputUnit doesn't contain any constants.
     if (constantValues == null) return;
     for (ConstantValue constantValue in constantValues) {
       _registry.registerConstant(outputUnit, constantValue);
       assert(!_constants.containsKey(constantValue));
       String name = namer.constantName(constantValue);
       String constantObject = namer.globalObjectForConstant(constantValue);
       Holder holder = _registry.registerHolder(constantObject);
       Constant constant = new Constant(name, holder, constantValue);
       _constants[constantValue] = constant;
     }
   }
 }