Move computation of method flags into model.

pkg/compiler/lib/src/js_emitter/old_emitter/container_builder.dart

 // Copyright (c) 2013, 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.
 
 part of dart2js.js_emitter;
 
 /// This class should morph into something that makes it easy to build
 /// JavaScript representations of libraries, class-sides, and instance-sides.
 /// Initially, it is just a placeholder for code that is moved from
 /// [CodeEmitterTask].
@@ skipping 222 matching lines @@
           if (!selector.appliesUnnamed(member, compiler.world)) continue;
           if (untypedSelectors.add(selector)) {
             // TODO(ahe): Is the last argument to [addParameterStub] needed?
             addParameterStub(member, selector, defineStub, new Set<String>());
           }
         }
       }
     }
   }
 
-  void addMember(Element member, ClassBuilder builder) {
-    assert(invariant(member, member.isDeclaration));
-
-    if (member.isField) {
-      addMemberField(member, builder);
-    } else if (member.isFunction ||
-               member.isGenerativeConstructorBody ||
-               member.isGenerativeConstructor ||
-               member.isAccessor) {
-      addMemberMethod(member, builder);
-    } else {
-      compiler.internalError(member,
-          'Unexpected kind: "${member.kind}".');
-    }
-  }
-
-  void addMemberMethod(FunctionElement member, ClassBuilder builder) {
-    MemberInfo info = analyzeMemberMethod(member);
-    if (info != null) {
-      addMemberMethodFromInfo(info, builder);
-    }
-  }
-
-  MemberInfo analyzeMemberMethod(FunctionElement member) {
-    if (member.isAbstract) return null;
-    jsAst.Expression code = backend.generatedCode[member];
-    if (code == null) return null;
-    String name = namer.getNameOfMember(member);
-
-    FunctionSignature parameters = member.functionSignature;
-    bool needsStubs = !parameters.optionalParameters.isEmpty;
-    bool canTearOff = false;
-    bool isClosure = false;
-    bool isNotApplyTarget = !member.isFunction ||
-                            member.isConstructor ||
-                            member.isAccessor;
-    String tearOffName;
-
-
-    final bool canBeReflected = backend.isAccessibleByReflection(member) ||
-        // During incremental compilation, we have to assume that reflection
-        // *might* get enabled.
-        compiler.hasIncrementalSupport;
-
-    if (isNotApplyTarget) {
-      canTearOff = false;
-    } else if (member.isInstanceMember) {
-      if (member.enclosingClass.isClosure) {
-        canTearOff = false;
-        isClosure = true;
-      } else {
-        // Careful with operators.
-        canTearOff =
-            compiler.codegenWorld.hasInvokedGetter(member, compiler.world) ||
-            (canBeReflected && !member.isOperator);
-        assert(!needsSuperGetter(member) || canTearOff);
-        tearOffName = namer.getterName(member);
-      }
-    } else {
-      canTearOff =
-          compiler.codegenWorld.staticFunctionsNeedingGetter.contains(member) ||
-          canBeReflected;
-      tearOffName = namer.getStaticClosureName(member);
-    }
-    final bool canBeApplied = compiler.enabledFunctionApply &&
-                              compiler.world.getMightBePassedToApply(member);
-
-    final bool hasSuperAlias = backend.isAliasedSuperMember(member);
+  void addMemberMethod(DartMethod method, ClassBuilder builder) {
+    final FunctionElement member = method.element;
+    String name = method.name;
+    final FunctionSignature parameters = member.functionSignature;
+    jsAst.Expression code = method.code;
+    final bool needsStubs = method.needsStubs;
+    final bool canTearOff = method.needsTearOff;
+    final String tearOffName = method.tearOffName;
+    final bool canBeReflected = method.canBeReflected;
+    final bool canBeApplied = method.canBeApplied;
+    final bool isClosure = method is InstanceMethod && method.isClosure;
+    final bool hasSuperAlias = method is InstanceMethod && method.hasSuperAlias;
 
     final bool needStructuredInfo =
         canTearOff || canBeReflected || canBeApplied || hasSuperAlias;
 
-
-    if (canTearOff) {
-      assert(invariant(member, !member.isGenerativeConstructor));
-      assert(invariant(member, !member.isGenerativeConstructorBody));
-      assert(invariant(member, !member.isConstructor));
-    }
-
-    return new MemberInfo(
-        member,
-        name,
-        parameters,
-        code,
-        needsStubs: needsStubs,
-        canTearOff: canTearOff,
-        isClosure: isClosure,
-        tearOffName: tearOffName,
-        canBeReflected: canBeReflected,
-        canBeApplied: canBeApplied,
-        hasSuperAlias: hasSuperAlias,
-        needStructuredInfo: needStructuredInfo
-    );
-  }
-
-  void addMemberMethodFromInfo(MemberInfo info, ClassBuilder builder) {
-    final FunctionElement member = info.member;
-    String name = info.name;
-    final FunctionSignature parameters = info.parameters;
-    jsAst.Expression code = info.code;
-    final bool needsStubs = info.needsStubs;
-    final bool canTearOff = info.canTearOff;
-    final bool isClosure = info.isClosure;
-    final String tearOffName = info.tearOffName;
-    final bool canBeReflected = info.canBeReflected;
-    final bool canBeApplied = info.canBeApplied;
-    final bool needStructuredInfo = info.needStructuredInfo;
-    final bool hasSuperAlias = info.hasSuperAlias;
-
     emitter.interceptorEmitter.recordMangledNameOfMemberMethod(member, name);
 
     if (!needStructuredInfo) {
       compiler.dumpInfoTask.registerElementAst(member,
           builder.addProperty(name, code));
       if (needsStubs) {
         addParameterStubs(
             member,
             (Selector selector, jsAst.Fun function) {
               compiler.dumpInfoTask.registerElementAst(member,
@@ skipping 162 matching lines @@
       expressions.add(js.string(namer.privateName(member.library,
                                                   member.name)));
     }
 
     jsAst.ArrayInitializer arrayInit =
       new jsAst.ArrayInitializer(expressions.toList());
     compiler.dumpInfoTask.registerElementAst(member,
         builder.addProperty(name, arrayInit));
   }
 
-  void addMemberField(VariableElement member, ClassBuilder builder) {
+  void addMemberField(Field field, ClassBuilder builder) {
     // For now, do nothing.
   }
 }
-
-class MemberInfo {
-  final FunctionElement member;
-
-  final String name;
-
-  final FunctionSignature parameters;
-
-  final jsAst.Expression code;
-
-  final bool needsStubs;
-
-  final bool canTearOff;
-
-  final bool isClosure;
-
-  final String tearOffName;
-
-  final bool canBeReflected;
-
-  final bool canBeApplied;
-
-  final bool needStructuredInfo;
-
-  final bool hasSuperAlias;
-
-  MemberInfo(
-      this.member,
-      this.name,
-      this.parameters,
-      this.code,
-      {this.needsStubs,
-       this.canTearOff,
-       this.isClosure,
-       this.tearOffName,
-       this.canBeReflected,
-       this.canBeApplied,
-       this.hasSuperAlias,
-       this.needStructuredInfo}) {
-    assert(member != null);
-    assert(name != null);
-    assert(parameters != null);
-    assert(code != null);
-    assert(needsStubs != null);
-    assert(canTearOff != null);
-    assert(isClosure != null);
-    assert(tearOffName != null || !canTearOff);
-    assert(canBeReflected != null);
-    assert(canBeApplied != null);
-    assert(hasSuperAlias != null);
-    assert(needStructuredInfo != null);
-  }
-}