Support the literal kind for native classes (ie Console).

frog/leg/emitter.dart

 // Copyright (c) 2012, 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.
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
 class ClosureInvocationElement extends FunctionElement {
   ClosureInvocationElement(SourceString name,
@@ skipping 156 matching lines @@
                          [bool isNative = false]) {
     Set<Selector> selectors = compiler.universe.invokedNames[member.name];
     if (selectors == null) return;
     for (Selector selector in selectors) {
       if (!selector.applies(compiler, member)) continue;
       addParameterStub(member, attachTo, buffer, selector, isNative);
     }
   }
 
   void addInstanceMember(Element member,
-                         String prototype,
-                         StringBuffer buffer) {
+                         String attachTo(String name),

[kasperl, 2012/03/02 13:11:33]

Does this mean that you're re-evaluating the native singleton expression over
and over again? Should you be caching it in a top-level variable instead so that
you never re-evaluate? Wouldn't that potentially make the code shorter too?

Do you really need this generality? Is there any case where attachTo doesn't
return something where name is a suffix?

[ngeoffray, 2012/03/05 08:28:00]

There are three cases:
1) Normal:
        className.prototype.memberName

2) Native with hidden prototype:
        $dynamic(memberName).className

3) Native with singelton literal:
        className.memberName

Also, I am not sure about your comment on re-evaluating the native singleton?
What this code will do is something like:

ConsoleJs.log$0 = ConsoleJs.log
ConsoleJs.foo$2 = ConsoleJs.foo

+                         StringBuffer buffer,
+                         [bool isNative = false]) {
     // TODO(floitsch): we don't need to deal with members of
     // uninstantiated classes, that have been overwritten by subclasses.
-    String attachTo(String name) => '$prototype.$name';
 
-    assert(member.isInstanceMember());
     if (member.kind === ElementKind.FUNCTION
         || member.kind === ElementKind.GENERATIVE_CONSTRUCTOR_BODY
         || member.kind === ElementKind.GETTER
         || member.kind === ElementKind.SETTER) {
       if (member.modifiers !== null && member.modifiers.isAbstract()) return;
       String codeBlock = compiler.universe.generatedCode[member];
       if (codeBlock == null) return;
-      buffer.add('$prototype.${namer.getName(member)} = $codeBlock;\n');
+      buffer.add('${attachTo(namer.getName(member))} = $codeBlock;\n');
       codeBlock = compiler.universe.generatedBailoutCode[member];
       if (codeBlock !== null) {
-        String name = namer.getBailoutName(member);
-        buffer.add('$prototype.$name = $codeBlock;\n');
+        String name = compiler.namer.getBailoutName(member);
+        buffer.add('${attachTo(name)} = $codeBlock;\n');
       }
       FunctionElement function = member;
-      if (!function.computeParameters(compiler).optionalParameters.isEmpty()) {
-        addParameterStubs(member, attachTo, buffer);
+      FunctionParameters parameters = function.computeParameters(compiler);
+      if (!parameters.optionalParameters.isEmpty()) {
+        addParameterStubs(member, attachTo, buffer, isNative: isNative);
       }
     } else if (member.kind === ElementKind.FIELD) {
-      // TODO(ngeoffray): Have another class generate the code for the
-      // fields.
       if ((member.modifiers === null || !member.modifiers.isFinal()) &&
           compiler.universe.invokedSetters.contains(member.name)) {
         String setterName = namer.setterName(member.name);
-        buffer.add('$prototype.$setterName = function(v){\n' +
-          '  this.${namer.getName(member)} = v;\n};\n');
+        String name =

[kasperl, 2012/03/02 13:11:33]

The name computation seems to be duplicated. Is there anyway to share that with
the getter part?

[ngeoffray, 2012/03/05 08:28:00]

I could share it, but that means it would be computed even in the case where
neither the getter and setter must be generated.

I think long-term we want the field case to be handled just like other members.
That's the TODO line 202 of the unchanged file. I'll add back the TODO.

+            isNative ? member.name.slowToString() : namer.getName(member);
+        buffer.add('${attachTo(setterName)} = function(v){\n');
+        buffer.add('  this.$name = v;\n};\n');
       }
       if (compiler.universe.invokedGetters.contains(member.name)) {
         String getterName = namer.getterName(member.name);
-        buffer.add('$prototype.$getterName = function(){\n' +
-          '  return this.${namer.getName(member)};\n};\n');
+        String name =
+            isNative ? member.name.slowToString() : namer.getName(member);
+        buffer.add('${attachTo(getterName)} = function(){\n');
+        buffer.add('  return this.$name;\n};\n');
       }
     } else {
       compiler.internalError('unexpected kind: "${member.kind}"',
                              element: member);
     }
-
-    if (member.kind == ElementKind.GETTER || member.kind == ElementKind.FIELD) {
-      Set<Selector> selectors = compiler.universe.invokedNames[member.name];
-      if (selectors !== null && !selectors.isEmpty()) {
-        emitCallStubForGetter(buffer, attachTo, member, selectors);
-      }
-    } else if (member.kind == ElementKind.FUNCTION) {
-      if (compiler.universe.invokedGetters.contains(member.name)) {
-        emitDynamicFunctionGetter(buffer, attachTo, member);
-      }
-    }
+    emitExtraAccessors(member, attachTo, buffer);
   }
 
   bool generateFieldInits(ClassElement classElement,
                           StringBuffer argumentsBuffer,
                           StringBuffer bodyBuffer) {
     bool isFirst = true;
     do {
       // TODO(floitsch): make sure there are no name clashes.
       String className = namer.getName(classElement);
 
@@ skipping 42 matching lines @@
       generateFieldInits(classElement, buffer, bodyBuffer);
     }
     buffer.add(') {\n');
     buffer.add(bodyBuffer);
     buffer.add('};\n');
     if (superclass !== null) {
       addInheritFunctionIfNecessary(buffer);
       String superName = namer.isolatePropertyAccess(superclass);
       buffer.add('${inheritsName}($className, $superName);\n');
     }
-    String prototype = '$className.prototype';
 
+    String attachTo(String name) => '$className.prototype.$name';
     for (Element member in classElement.members) {
       if (member.isInstanceMember()) {
-        addInstanceMember(member, prototype, buffer);
+        addInstanceMember(member, attachTo, buffer);
       }
     }
     for (Element member in classElement.backendMembers) {
       if (member.isInstanceMember()) {
-        addInstanceMember(member, prototype, buffer);
+        addInstanceMember(member, attachTo, buffer);
       }
     }
     generateTypeTests(classElement, (Element other) {
-      buffer.add('$prototype.${namer.operatorIs(other)} = true;\n');
+      buffer.add('${attachTo(namer.operatorIs(other))} = true;\n');
     });
 
     if (superclass === null) {
       // Emit the noSuchMethods on the Object prototype now, so that
       // the code in the dynamicMethod can find them. Note that the
       // code in dynamicMethod is invoked before analyzing the full JS
       // script.
       emitNoSuchMethodCalls(buffer);
     }
   }
@@ skipping 205 matching lines @@
         constants.getStaticFinalFieldsForEmission();
     for (VariableElement element in staticFinalFields) {
       buffer.add('${namer.isolatePropertyAccess(element)} = ');
       compiler.withCurrentElement(element, () {
           constants.writeJsCodeForVariable(buffer, element);
         });
       buffer.add(';\n');
     }
   }
 
+  void emitExtraAccessors(Element member,
+                          String attachTo(String name),
+                          StringBuffer buffer) {
+    if (member.kind == ElementKind.GETTER || member.kind == ElementKind.FIELD) {
+      Set<Selector> selectors = compiler.universe.invokedNames[member.name];
+      if (selectors !== null && !selectors.isEmpty()) {
+        compiler.emitter.emitCallStubForGetter(
+            buffer, attachTo, member, selectors);
+      }
+    } else if (member.kind == ElementKind.FUNCTION) {
+      if (compiler.universe.invokedGetters.contains(member.name)) {
+        compiler.emitter.emitDynamicFunctionGetter(
+            buffer, attachTo, member);
+      }
+    }
+  }
+
   void emitNoSuchMethodCalls(StringBuffer buffer) {
     // Do not generate no such method calls if there is no class.
     if (compiler.universe.instantiatedClasses.isEmpty()) return;
 
     // TODO(ngeoffray): We don't need to generate these methods if
     // nobody overwrites noSuchMethod.
 
     ClassElement objectClass =
         compiler.coreLibrary.find(const SourceString('Object'));
     String className = namer.isolatePropertyAccess(objectClass);
@@ skipping 58 matching lines @@
       emitStaticFinalFieldInitializations(buffer);
       nativeEmitter.emitDynamicDispatchMetadata(buffer);
       buffer.add('var ${namer.CURRENT_ISOLATE} = new ${namer.ISOLATE}();\n');
       Element main = compiler.mainApp.find(Compiler.MAIN);
       buffer.add('${namer.isolateAccess(main)}();\n');
       compiler.assembledCode = buffer.toString();
     });
     return compiler.assembledCode;
   }
 }