Implement JsMethodMirror.parameters.

dart/sdk/lib/_internal/compiler/implementation/js_backend/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.
 
 part of js_backend;
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
@@ skipping 67 matching lines @@
   String classesCollector;
   final Set<ClassElement> neededClasses = new Set<ClassElement>();
   final List<ClassElement> regularClasses = <ClassElement>[];
   final List<ClassElement> deferredClasses = <ClassElement>[];
   final List<ClassElement> nativeClasses = <ClassElement>[];
   final List<Selector> trivialNsmHandlers = <Selector>[];
   final Map<String, String> mangledFieldNames = <String, String>{};
   final Set<String> recordedMangledNames = new Set<String>();
   final Set<String> interceptorInvocationNames = new Set<String>();
 
+  /// A list of JS expressions that represent metadata, parameter names and
+  /// type, and return types.
+  final List<String> globalMetadata = [];
+
+  /// A map used to canonicalize the entries of globalMetadata.
+  final Map<String, int> globalMetadataMap = <String, int>{};
+
   // TODO(ngeoffray): remove this field.
   Set<ClassElement> instantiatedClasses;
 
   final List<jsAst.Expression> boundClosures = <jsAst.Expression>[];
 
   JavaScriptBackend get backend => compiler.backend;
 
   String get _ => compiler.enableMinification ? "" : " ";
   String get n => compiler.enableMinification ? "" : "\n";
   String get N => compiler.enableMinification ? "\n" : ";\n";
@@ skipping 1102 matching lines @@
     if (member.isFunction()
         || member.isGenerativeConstructorBody()
         || member.isAccessor()) {
       if (member.isAbstract(compiler)) return;
       jsAst.Expression code = backend.generatedCode[member];
       if (code == null) return;
       String name = namer.getName(member);
       if (backend.isInterceptedMethod(member)) {
         interceptorInvocationNames.add(name);
       }
+      code = extendWithMetadata(member, code);
       builder.addProperty(name, code);
-      var metadata = buildMetadataFunction(member);
-      if (metadata != null) {
-        builder.addProperty('@$name', metadata);
-      }
       String reflectionName = getReflectionName(member, name);
       if (reflectionName != null) {
         builder.addProperty('+$reflectionName', js('0'));
       }
       code = backend.generatedBailoutCode[member];
       if (code != null) {
         builder.addProperty(namer.getBailoutName(member), code);
       }
       FunctionElement function = member;
       FunctionSignature parameters = function.computeSignature(compiler);
@@ skipping 824 matching lines @@
         backend.generatedCode.keys.where(isStaticFunction);
     Set<Element> pendingElementsWithBailouts =
         backend.generatedBailoutCode.keys
             .where(isStaticFunction)
             .toSet();
 
     for (Element element in Elements.sortedByPosition(elements)) {
       CodeBuffer buffer = bufferForElement(element, eagerBuffer);
       jsAst.Expression code = backend.generatedCode[element];
       String name = namer.getName(element);
+      code = extendWithMetadata(element, code);
       emitStaticFunction(buffer, name, code);
-      var metadata = buildMetadataFunction(element);
-      if (metadata != null) {
-        buffer.write(',$n$n"@$name":$_');
-        buffer.write(jsAst.prettyPrint(metadata, compiler));
-      }
       String reflectionName = getReflectionName(element, name);
       if (reflectionName != null) {
         buffer.write(',$n$n"+$reflectionName":${_}0');
       }
       jsAst.Expression bailoutCode = backend.generatedBailoutCode[element];
       if (bailoutCode != null) {
         pendingElementsWithBailouts.remove(element);
         emitStaticFunction(buffer, namer.getBailoutName(element), bailoutCode);
       }
     }
@@ skipping 1180 matching lines @@
             metadata.add(constantReference(value));
           }
         }
       }
       if (metadata.isEmpty) return null;
       return js.fun(
           [], [js.return_(new jsAst.ArrayInitializer.from(metadata))]);
     });
   }
 
+  int reifyMetadata(MetadataAnnotation annotation) {
+    Constant value = annotation.value;
+    if (value == null) {
+      compiler.reportInternalError(
+          annotation, 'Internal error: value is null');
+      return -1;
+    }
+    return addGlobalMetadata(
+        jsAst.prettyPrint(constantReference(value), compiler).getText());
+  }
+
+  int reifyType(DartType type) {
+    // TODO(ahe): Handle type variables correctly instead of using "#".
+    String representation = backend.rti.getTypeRepresentation(type, (_) {});
+    return addGlobalMetadata(representation.replaceAll('#', 'null'));
+  }
+
+  int reifyName(SourceString name) {
+    return addGlobalMetadata('"${name.slowToString()}"');
+  }
+
+  int addGlobalMetadata(String string) {
+    return globalMetadataMap.putIfAbsent(
+        string,
+        () => (globalMetadata..add(string)).length - 1);

[kasperl, 2013/06/28 10:18:09]

I think this is a little bit hard to read.

[ahe, 2013/06/28 11:07:12]

Done.

+  }
+
+  jsAst.Fun extendWithMetadata(FunctionElement element, jsAst.Fun code) {
+    if (!backend.retainMetadataOf(element)) return code;
+    return compiler.withCurrentElement(element, () {
+      List<int> metadata = <int>[];
+      FunctionSignature signature = element.functionSignature;
+      if (element.isConstructor()) {
+        metadata.add(reifyType(element.getEnclosingClass().thisType));
+      } else {
+        metadata.add(reifyType(signature.returnType));
+      }
+      signature.forEachParameter((Element parameter) {
+        metadata
+            ..add(reifyName(parameter.name))
+            ..add(reifyType(parameter.computeType(compiler)));
+      });
+      Link link = element.metadata;
+      // TODO(ahe): Why is metadata sometimes null?
+      if (link != null) {
+        for (; !link.isEmpty; link = link.tail) {
+          metadata.add(reifyMetadata(link.head));
+        }
+      }
+      code.body.statements.add(js.string(metadata.join(',')).toStatement());
+      return code;
+    });
+  }
+
+  void emitMetadata(CodeBuffer buffer) {
+    buffer.write('init.metadata$_=$_[');
+    for (var metadata in globalMetadata) {
+      if (metadata is String) {
+        if (metadata != 'null') {
+          buffer.write(metadata);
+        }
+      } else {
+        throw 'Unexpected value in metadata: ${Error.safeToString(metadata)}';
+      }
+      buffer.write(',$n');
+    }
+    buffer.write('];$n');
+  }
+
   String assembleProgram() {
     measure(() {
       // Compute the required type checks to know which classes need a
       // 'is$' method.
       computeRequiredTypeChecks();
 
       computeNeededClasses();
 
       mainBuffer.add(buildGeneratedBy());
       addComment(HOOKS_API_USAGE, mainBuffer);
@@ skipping 138 matching lines @@
       emitCompileTimeConstants(mainBuffer);
       // Static field initializations require the classes and compile-time
       // constants to be set up.
       emitStaticNonFinalFieldInitializations(mainBuffer);
       emitOneShotInterceptors(mainBuffer);
       emitInterceptedNames(mainBuffer);
       emitLazilyInitializedStaticFields(mainBuffer);
 
       mainBuffer.add(nativeBuffer);
 
+      emitMetadata(mainBuffer);
 
       isolateProperties = isolatePropertiesName;
       // The following code should not use the short-hand for the
       // initialStatics.
       mainBuffer.add('var ${namer.CURRENT_ISOLATE}$_=${_}null$N');
 
       emitFinishIsolateConstructorInvocation(mainBuffer);
       mainBuffer.add('var ${namer.CURRENT_ISOLATE}$_='
                      '${_}new ${namer.isolateName}()$N');
 
@@ skipping 196 matching lines @@
 
 const String HOOKS_API_USAGE = """
 // The code supports the following hooks:
 // dartPrint(message)   - if this function is defined it is called
 //                        instead of the Dart [print] method.
 // dartMainRunner(main) - if this function is defined, the Dart [main]
 //                        method will not be invoked directly.
 //                        Instead, a closure that will invoke [main] is
 //                        passed to [dartMainRunner].
 """;