When metadata is not requested, elide unneeded signatures

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';
@@ skipping 1806 matching lines @@
     var tStaticSetters = <JS.Property>[];
     var tInstanceSetters = <JS.Property>[];
     var sNames = <JS.Expression>[];
     for (MethodDeclaration node in methods) {
       var name = node.name.name;
       var element = resolutionMap.elementDeclaredByMethodDeclaration(node);
       // TODO(vsm): Clean up all the nasty duplication.
       if (node.isAbstract) {
         continue;
       }
-
+      if (node.isStatic &&
+          !options.emitMetadata &&
+          (node.isGetter || node.isSetter)) {
+        continue;
+      }
       List<JS.Property> tMember;
       Function getOverride;
       Function lookup;
       Function elementToType;
       if (node.isGetter) {
         elementToType = (ExecutableElement element) => element.type;
         getOverride = classElem.lookUpInheritedConcreteGetter;
         lookup = classElem.type.lookUpInheritedGetter;
         tMember = node.isStatic ? tStaticGetters : tInstanceGetters;
       } else if (node.isSetter) {
         elementToType = (ExecutableElement element) => element.type;
         getOverride = classElem.lookUpInheritedConcreteSetter;
         lookup = classElem.type.lookUpInheritedSetter;
         tMember = node.isStatic ? tStaticSetters : tInstanceSetters;
       } else {
         // Method
         // Swap in "Object" for parameter types that are covariant overrides.
         var objectType = context.typeProvider.objectType;
         elementToType =
             (MethodElement element) => element.getReifiedType(objectType);
         getOverride = classElem.lookUpInheritedConcreteMethod;
         lookup = classElem.type.lookUpInheritedMethod;
         tMember = node.isStatic ? tStaticMethods : tInstanceMethods;
       }
 
       DartType reifiedType = elementToType(element);
-      var type = _emitAnnotatedFunctionType(reifiedType, node.metadata,
-          parameters: node.parameters?.parameters,
-          nameType: options.hoistSignatureTypes,
-          hoistType: options.hoistSignatureTypes,
-          definite: true);
-
       // Don't add redundant signatures for inherited methods whose signature
       // did not change.  If we are not overriding, or if the thing we are
       // overriding has a different reified type from ourselves, we must
       // emit a signature on this class.  Otherwise we will inherit the
       // signature from the superclass.
       var needsSignature = getOverride(name, currentLibrary) == null ||
           elementToType(
                   lookup(name, library: currentLibrary, thisType: false)) !=
               reifiedType;
 
+      var type = _emitAnnotatedFunctionType(reifiedType, node.metadata,
+          parameters: node.parameters?.parameters,
+          nameType: options.hoistSignatureTypes,
+          hoistType: options.hoistSignatureTypes,
+          definite: true);
+
       if (needsSignature) {
         var memberName = _declareMemberName(element);
         var property = new JS.Property(memberName, type);
         tMember.add(property);
-        // TODO(vsm): Why do we need this?
+        // We record the names of static methods seperately so we can
+        // attach metadata to them individually.
+        // TODO(leafp): Revisit 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 = _declareMemberName(element.getter);
-        var type = _emitAnnotatedType(element.type, node.metadata);
-        var property = new JS.Property(memberName, type);
-        (node.isStatic ? tStaticFields : tInstanceFields).add(property);
+      if (!node.isStatic || options.emitMetadata) {
+        for (VariableDeclaration field in node.fields.variables) {
+          var element = field.element as FieldElement;
+          var memberName = _declareMemberName(element.getter);
+          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 = resolutionMap.elementDeclaredByConstructorDeclaration(node);
-      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);
+    if (options.emitMetadata) {
+      for (ConstructorDeclaration node in ctors) {
+        var memberName = _constructorName(node.element);
+        var element =
+            resolutionMap.elementDeclaredByConstructorDeclaration(node);
+        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);
+      }
     }
-
     var sigFields = <JS.Property>[];
     if (!tCtors.isEmpty) {
       sigFields.add(_buildSignatureField('constructors', tCtors));
     }
     if (!tInstanceFields.isEmpty) {
       sigFields.add(_buildSignatureField('fields', tInstanceFields));
     }
     if (!tInstanceGetters.isEmpty) {
       sigFields.add(_buildSignatureField('getters', tInstanceGetters));
     }
     if (!tInstanceSetters.isEmpty) {
       sigFields.add(_buildSignatureField('setters', tInstanceSetters));
     }
     if (!tInstanceMethods.isEmpty) {
       sigFields.add(_buildSignatureField('methods', tInstanceMethods));
     }
     if (!tStaticFields.isEmpty) {
       sigFields.add(_buildSignatureField('sfields', tStaticFields));
     }
     if (!tStaticGetters.isEmpty) {
       sigFields.add(_buildSignatureField('sgetters', tStaticGetters));
     }
     if (!tStaticSetters.isEmpty) {
       sigFields.add(_buildSignatureField('ssetters', tStaticSetters));
     }
     if (!tStaticMethods.isEmpty) {
       assert(!sNames.isEmpty);
-      // TODO(vsm): Why do we need this names field?
+      // Emit names so that we can lazily attach metadata to statics
+      // TODO(leafp): revisit this strategy
       var aNames = new JS.Property(
           _propertyName('names'), new JS.ArrayInitializer(sNames));
       sigFields.add(_buildSignatureField('statics', tStaticMethods));
       sigFields.add(aNames);
     }
     if (!sigFields.isEmpty || extensions.isNotEmpty) {
       var sig = new JS.ObjectInitializer(sigFields);
       body.add(_callHelperStatement('setSignature(#, #);', [className, sig]));
     }
     // Add static property dart._runtimeType to Object.
@@ skipping 3946 matching lines @@
   if (targetIdentifier.staticElement is! PrefixElement) return false;
   var prefix = targetIdentifier.staticElement as PrefixElement;
 
   // The library the prefix is referring to must come from a deferred import.
   var containingLibrary = resolutionMap
       .elementDeclaredByCompilationUnit(target.root as CompilationUnit)
       .library;
   var imports = containingLibrary.getImportsWithPrefix(prefix);
   return imports.length == 1 && imports[0].isDeferred;
 }