Move computation of method flags into model.

pkg/compiler/lib/src/js_emitter/model.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.new_js_emitter.model;
 
 import '../js/js.dart' as js show Expression;
 import '../constants/values.dart' show ConstantValue;
 
 import '../deferred_load.dart' show OutputUnit;
@@ skipping 269 matching lines @@
         this.getterFlags, this.setterFlags,
         this.needsCheckedSetter);
 
   bool get needsGetter => getterFlags != 0;
   bool get needsUncheckedSetter => setterFlags != 0;
 
   bool get needsInterceptedGetter => getterFlags > 1;
   bool get needsInterceptedSetter => setterFlags > 1;
 }
 
-class Method {
+abstract class Method {
   /// The element should only be used during the transition to the new model.
   /// Uses indicate missing information in the model.
   final Element element;
-
   final String name;
   final js.Expression code;
+
+  Method(this.element, this.name, this.code);
+}
+
+class DartMethod extends Method {

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

Add comment what a "DartMethod" is.

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

Done.

   final bool needsTearOff;
+  final String tearOffName;
+  // TODO(herhut): Directly store stubs instead/
+  final bool needsStubs;
+  // TODO(herhut): Directly store aliases instead.
+  final bool canBeApplied;
+  final bool canBeReflected;

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

It would be an option to keep the "canBeReflected" part out of here.
The whole reflection code is only in the old emitter anyway.

I'm fine either way.

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

I will remove it again later if it can be pushed into the old emitter easily.

 
-  Method(this.element, this.name, this.code, {this.needsTearOff}) {
+  DartMethod(Element element, String name, js.Expression code,
+      {this.needsTearOff, this.tearOffName, this.needsStubs, this.canBeApplied,
+        this.canBeReflected})

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

nit: indent one less.

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

Done.

+      : super(element, name, code) {
     assert(needsTearOff != null);
+    assert(!needsTearOff || tearOffName != null);
+    assert(canBeApplied != null);
+    assert(canBeReflected != null);
+    assert(needsStubs != null);
+  }
+}
+
+class InstanceMethod extends DartMethod {
+  // TODO(herhut): Directly store aliases instead.
+  final bool hasSuperAlias;
+  final bool isClosure;
+
+  InstanceMethod(element, name, code,
+      {bool needsTearOff,
+       String tearOffName,
+       this.hasSuperAlias,
+       bool canBeApplied,
+       bool canBeReflected,
+       this.isClosure,
+       bool needsStubs})
+      : super(element, name, code,
+        needsTearOff: needsTearOff,

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

I would align with "(".

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

Done.

+        tearOffName: tearOffName,
+        canBeApplied: canBeApplied,
+        canBeReflected: canBeReflected,
+        needsStubs: needsStubs) {
+    assert(hasSuperAlias != null);
+    assert(isClosure != null);
   }
 }
 
 class StubMethod extends Method {
   StubMethod(String name, js.Expression code,
-             {bool needsTearOff, Element element })
-      : super(element, name, code, needsTearOff: needsTearOff);
+             {Element element})
+      : super(element, name, code);
 }
 
-class StaticMethod extends Method {
+class StaticMethod extends DartMethod {
   final Holder holder;
   StaticMethod(Element element, String name, this.holder, js.Expression code,
-               {bool needsTearOff})
-      : super(element, name, code, needsTearOff: needsTearOff);
+               {bool needsTearOff, String tearOffName, bool canBeApplied,
+                bool canBeReflected, bool needsStubs})
+      : super(element, name, code,
+          needsTearOff: needsTearOff,

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

I would align with the "(".

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

Done.

+          tearOffName : tearOffName,
+          canBeApplied : canBeApplied,
+          canBeReflected : canBeReflected,
+          needsStubs : needsStubs);
 }
 
-class StaticStubMethod extends StaticMethod {
-  StaticStubMethod(String name, Holder holder, js.Expression code,
-                   {bool needsTearOff})
-      : super(null, name, holder, code, needsTearOff: needsTearOff);
+class StaticStubMethod extends StubMethod {
+  Holder holder;
+  StaticStubMethod(String name, this.holder, js.Expression code,
+                   {bool needsTearOff, String tearOffName})
+      : super(name, code) {
+    assert(needsTearOff == false);

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

Will this change?
If not, why get it as an argument?

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

The original callsites to this had the tearoff parameter with a TODO to compute
its value. Currently, there is no place to put the tearoff in the model, but I
did not want to remove the TODO until I am sure it is always false.

Removed now.

+  }
 }