More DDC mirrors support

pkg/dev_compiler/lib/src/compiler/code_generator.dart

 // Copyright (c) 2015, 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.
 
 import 'dart:collection' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
@@ skipping 715 matching lines @@
     _defineClass(classElem, className, classExpr, isCallable, body);
 
     // Emit things that come after the ES6 `class ... { ... }`.
     var jsPeerName = _getJSPeerName(classElem);
     _setBaseClass(classElem, className, jsPeerName, body);
 
     _emitClassTypeTests(classElem, className, body);
 
     _defineNamedConstructors(ctors, body, className, isCallable);
     _emitVirtualFieldSymbols(virtualFieldSymbols, body);
-    _emitClassSignature(methods, classElem, ctors, extensions, className, body);
+    _emitClassSignature(
+        methods, allFields, classElem, ctors, extensions, className, body);
     _defineExtensionMembers(extensions, className, body);
     _emitClassMetadata(node.metadata, className, body);
 
     JS.Statement classDef = _statement(body);
     var typeFormals = classElem.typeParameters;
     if (typeFormals.isNotEmpty) {
       classDef = _defineClassTypeArguments(classElem, typeFormals, classDef);
     }
 
     body = <JS.Statement>[classDef];
@@ skipping 896 matching lines @@
       body.add(js.statement('dart.defineExtensionMembers(#, #);', [
         className,
         new JS.ArrayInitializer(methodNames, multiline: methodNames.length > 4)
       ]));
     }
   }
 
   /// Emit the signature on the class recording the runtime type information
   void _emitClassSignature(
       List<MethodDeclaration> methods,
+      List<FieldDeclaration> fields,
       ClassElement classElem,
       List<ConstructorDeclaration> ctors,
       List<ExecutableElement> extensions,
       JS.Expression className,
       List<JS.Statement> body) {
     if (classElem.interfaces.isNotEmpty) {
       body.add(js.statement('#[dart.implements] = () => #;', [
         className,
         new JS.ArrayInitializer(
             new List<JS.Expression>.from(classElem.interfaces.map(_emitType)))
       ]));
     }
 
-    var tStatics = <JS.Property>[];
-    var tMethods = <JS.Property>[];
+    var tStaticMethods = <JS.Property>[];
+    var tInstanceMethods = <JS.Property>[];
+    var tStaticGetters = <JS.Property>[];
+    var tInstanceGetters = <JS.Property>[];
+    var tStaticSetters = <JS.Property>[];
+    var tInstanceSetters = <JS.Property>[];
     var sNames = <JS.Expression>[];
     for (MethodDeclaration node in methods) {
-      if (!(node.isSetter || node.isGetter || node.isAbstract)) {
-        var name = node.name.name;
-        var element = node.element;
-        var inheritedElement =
-            classElem.lookUpInheritedConcreteMethod(name, currentLibrary);
-        if (inheritedElement != null && inheritedElement.type == element.type) {
-          continue;
-        }
-        var memberName = _elementMemberName(element,
-            useExtension: _extensionTypes.isNativeClass(classElem));
-        var type = _emitFunctionType(element.type,
-            nameType: options.hoistSignatureTypes,
-            hoistType: options.hoistSignatureTypes,
-            definite: true);
-        var property = new JS.Property(memberName, type);
-        if (node.isStatic) {
-          tStatics.add(property);
-          sNames.add(memberName);
-        } else {
-          tMethods.add(property);
-        }
+      var name = node.name.name;
+      var element = node.element;
+      // TODO(vsm): Clean up all the nasty duplication.
+      if (node.isAbstract) {
+        continue;
+      }
+
+      Function lookup;
+      List<JS.Property> tMember;
+      JS.Expression type;
+      if (node.isGetter) {
+        lookup = classElem.lookUpInheritedConcreteGetter;
+        tMember = node.isStatic ? tStaticGetters : tInstanceGetters;
+      } else if (node.isSetter) {
+        lookup = classElem.lookUpInheritedConcreteSetter;
+        tMember = node.isStatic ? tStaticSetters : tInstanceSetters;
+      } else {
+        // Method
+        lookup = classElem.lookUpInheritedConcreteMethod;
+        tMember = node.isStatic ? tStaticMethods : tInstanceMethods;
+      }
+
+      type = _emitAnnotatedFunctionType(element.type, node.metadata,
+          parameters: node.parameters?.parameters,
+          nameType: options.hoistSignatureTypes,
+          hoistType: options.hoistSignatureTypes,
+          definite: true);
+
+      var inheritedElement = lookup(name, currentLibrary);
+      if (inheritedElement != null && inheritedElement.type == element.type) {
+        continue;
+      }
+      var memberName = _elementMemberName(element,
+          useExtension: _extensionTypes.isNativeClass(classElem));
+      var property = new JS.Property(memberName, type);
+      tMember.add(property);
+      // TODO(vsm): Why do we need this?
+      if (node.isStatic && !node.isGetter && !node.isSetter) {
+        sNames.add(memberName);
       }
     }
 
+    var tInstanceFields = <JS.Property>[];
+    var tStaticFields = <JS.Property>[];
+    for (FieldDeclaration node in fields) {
+      for (VariableDeclaration field in node.fields.variables) {
+        var element = field.element as FieldElement;
+        var memberName = _elementMemberName(element.getter,
+            useExtension: _extensionTypes.isNativeClass(classElem));
+        var type = _emitAnnotatedType(element.type, node.metadata);
+        var property = new JS.Property(memberName, type);
+        (node.isStatic ? tStaticFields : tInstanceFields).add(property);
+      }
+    }
+
     var tCtors = <JS.Property>[];
     for (ConstructorDeclaration node in ctors) {
       var memberName = _constructorName(node.element);
       var element = node.element;
-      var type = _emitFunctionType(element.type,
+      var type = _emitAnnotatedFunctionType(element.type, node.metadata,
           parameters: node.parameters.parameters,
           nameType: options.hoistSignatureTypes,
           hoistType: options.hoistSignatureTypes,
           definite: true);
       var property = new JS.Property(memberName, type);
       tCtors.add(property);
     }
 
     JS.Property build(String name, List<JS.Property> elements) {
       var o =
           new JS.ObjectInitializer(elements, multiline: elements.length > 1);
+      // TODO(vsm): Remove
       var e = js.call('() => #', o);
       return new JS.Property(_propertyName(name), e);
     }
 
     var sigFields = <JS.Property>[];
     if (!tCtors.isEmpty) sigFields.add(build('constructors', tCtors));
-    if (!tMethods.isEmpty) sigFields.add(build('methods', tMethods));
-    if (!tStatics.isEmpty) {
+    if (!tInstanceFields.isEmpty)

[Jennifer Messerly, 2016/09/01 16:42:43]

style nit: add curly braces since it didn't fit on one line?

(not a big deal to me tho)

+      sigFields.add(build('fields', tInstanceFields));
+    if (!tInstanceGetters.isEmpty)
+      sigFields.add(build('getters', tInstanceGetters));
+    if (!tInstanceSetters.isEmpty)
+      sigFields.add(build('setters', tInstanceSetters));
+    if (!tInstanceMethods.isEmpty)
+      sigFields.add(build('methods', tInstanceMethods));
+    if (!tStaticFields.isEmpty) sigFields.add(build('sfields', tStaticFields));
+    if (!tStaticGetters.isEmpty)
+      sigFields.add(build('sgetters', tStaticGetters));
+    if (!tStaticSetters.isEmpty)
+      sigFields.add(build('ssetters', tStaticSetters));
+    if (!tStaticMethods.isEmpty) {
       assert(!sNames.isEmpty);
+      // TODO(vsm): Why do we need this names field?
       var aNames = new JS.Property(
           _propertyName('names'), new JS.ArrayInitializer(sNames));
-      sigFields.add(build('statics', tStatics));
+      sigFields.add(build('statics', tStaticMethods));
       sigFields.add(aNames);
     }
     if (!sigFields.isEmpty || extensions.isNotEmpty) {
       var sig = new JS.ObjectInitializer(sigFields);
       body.add(js.statement('dart.setSignature(#, #);', [className, sig]));
     }
     // Add static property dart._runtimeType to Object.
     // All other Dart classes will (statically) inherit this property.
     if (classElem == objectClass) {
       body.add(js.statement('dart.tagComputed(#, () => #.#);',
@@ skipping 930 matching lines @@
 
     var type = declaration ? emitTypeRef(element.type) : null;
     return new JS.Identifier(element.name, type: type);
   }
 
   List<Annotation> _parameterMetadata(FormalParameter p) =>
       (p is NormalFormalParameter)
           ? p.metadata
           : (p as DefaultFormalParameter).parameter.metadata;
 
+  // Wrap a result - usually a type - with its metadata.  The runtime is
+  // responsible for unpacking this.
+  JS.Expression _emitAnnotatedResult(
+      JS.Expression result, List<Annotation> metadata) {
+    if (options.emitMetadata && metadata != null && metadata.isNotEmpty) {
+      result = new JS.ArrayInitializer(
+          [result]..addAll(metadata.map(_instantiateAnnotation)));
+    }
+    return result;
+  }
+
+  JS.Expression _emitAnnotatedType(DartType type, List<Annotation> metadata,
+      {bool nameType: true, bool hoistType: true}) {
+    metadata ??= [];
+    var typeName = _emitType(type, nameType: nameType, hoistType: hoistType);
+    return _emitAnnotatedResult(typeName, metadata);
+  }
+
   JS.ArrayInitializer _emitTypeNames(
       List<DartType> types, List<FormalParameter> parameters,
       {bool nameType: true, bool hoistType: true}) {
     var result = <JS.Expression>[];
     for (int i = 0; i < types.length; ++i) {
-      var metadata =
-          parameters != null ? _parameterMetadata(parameters[i]) : [];
-      var typeName =
-          _emitType(types[i], nameType: nameType, hoistType: hoistType);
-      var value = typeName;
-      if (options.emitMetadata && metadata.isNotEmpty) {
-        value = new JS.ArrayInitializer(
-            [typeName]..addAll(metadata.map(_instantiateAnnotation)));
-      }
-      result.add(value);
+      var metadata = parameters != null
+          ? _parameterMetadata(parameters[i])
+          : <Annotation>[];
+      result.add(_emitAnnotatedType(types[i], metadata));
     }
     return new JS.ArrayInitializer(result);
   }
 
   JS.ObjectInitializer _emitTypeProperties(Map<String, DartType> types) {
     var properties = <JS.Property>[];
     types.forEach((name, type) {
       var key = _propertyName(name);
       var value = _emitType(type);
       properties.add(new JS.Property(key, value));
@@ skipping 14 matching lines @@
         lowerTypedef: lowerTypedef,
         nameType: nameType,
         hoistType: hoistType);
     var helper = (definite) ? 'definiteFunctionType' : 'functionType';
     var fullType = js.call('dart.${helper}(#)', [parts]);
     if (!nameType) return fullType;
     return _typeTable.nameType(type, fullType,
         hoistType: hoistType, definite: definite);
   }
 
+  JS.Expression _emitAnnotatedFunctionType(
+      FunctionType type, List<Annotation> metadata,
+      {List<FormalParameter> parameters,
+      bool lowerTypedef: false,
+      bool nameType: true,
+      bool hoistType: true,
+      bool definite: false}) {
+    var result = _emitFunctionType(type,
+        parameters: parameters,
+        lowerTypedef: lowerTypedef,
+        nameType: nameType,
+        hoistType: hoistType,
+        definite: definite);
+    return _emitAnnotatedResult(result, metadata);
+  }
+
   /// Emit the pieces of a function type, as an array of return type,
   /// regular args, and optional/named args.
   List<JS.Expression> _emitFunctionTypeParts(FunctionType type,
       {List<FormalParameter> parameters,
       bool lowerTypedef: false,
       bool nameType: true,
       bool hoistType: true}) {
     var parameterTypes = type.normalParameterTypes;
     var optionalTypes = type.optionalParameterTypes;
     var namedTypes = type.namedParameterTypes;
@@ skipping 2632 matching lines @@
 }
 
 bool isLibraryPrefix(Expression node) =>
     node is SimpleIdentifier && node.staticElement is PrefixElement;
 
 LibraryElement _getLibrary(AnalysisContext c, String uri) =>
     c.computeLibraryElement(c.sourceFactory.forUri(uri));
 
 bool _isDartRuntime(LibraryElement l) =>
     l.isInSdk && l.source.uri.toString() == 'dart:_runtime';