fix #27258, don't allow dynamic set of a final field

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 1285 matching lines @@
 
     // Create enum class
     var classExpr = new JS.ClassExpression(new JS.Identifier(type.name),
         _emitClassHeritage(element), [constructor, toStringF]);
     var id = _emitTopLevelName(element);
 
     // Emit metadata for synthetic enum index member.
     // TODO(jacobr): make field readonly when that is supported.
     var tInstanceFields = <JS.Property>[
       new JS.Property(
-          _emitMemberName('index'), _emitAnnotatedType(intClass.type, null))
+          _emitMemberName('index'), _emitFieldSignature(types.intType))
     ];
-    var sigFields = <JS.Property>[
-      _buildSignatureField('fields', tInstanceFields)
-    ];
+    var sigFields = <JS.Property>[];
+    _buildSignatureField(sigFields, 'fields', tInstanceFields);
     var sig = new JS.ObjectInitializer(sigFields);
 
     var result = [
       js.statement('# = #', [id, classExpr]),
       _callHelperStatement('setSignature(#, #);', [id, sig])
     ];
 
     // defineEnumValues internally depends on dart.constList which uses
     // _interceptors.JSArray.
     _declareBeforeUse(_jsArray);
@@ skipping 518 matching lines @@
         new JS.ArrayInitializer(names, multiline: names.length > 4)
       ]));
     }
 
     // Define mixin members (if any) on the mixin class.
     var mixinClass = js.call('#.__proto__', [className]);
     emitExtensions(mixinClass, _classProperties.mixinExtensionMembers);
     emitExtensions(className, _classProperties.extensionMembers);
   }
 
-  JS.Property _buildSignatureField(String name, List<JS.Property> elements) {
+  void _buildSignatureField(
+      List<JS.Property> sigFields, String name, List<JS.Property> elements) {
+    if (elements.isEmpty) return;
     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);
+    sigFields.add(new JS.Property(_propertyName(name), e));
   }
 
   /// Emit the signature on the class recording the runtime type information
   void _emitClassSignature(
       List<MethodDeclaration> methods,
       List<FieldDeclaration> fields,
       ClassElement classElem,
       List<ConstructorDeclaration> ctors,
       JS.Expression className,
       List<JS.Statement> body) {
@@ skipping 13 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 &&
+      // Static getters/setters cannot be called with dynamic dispatch, nor
+      // can they be torn off.
+      // TODO(jmesserly): can we attach static method type info at the tearoff
+      // point, and avoid saving the information otherwise? Same trick would
+      // work for top-level functions.
+      if (!options.emitMetadata &&
+          node.isStatic &&
           (node.isGetter || node.isSetter)) {
         continue;
       }
       List<JS.Property> tMember;
+      // TODO(jmesserly): these 3 variables should be typed.
       Function getOverride;
       Function lookup;
       Function elementToType;
+      // TODO(jmesserly): we could reduce work by not saving a full function
+      // type for getters/setters. These only need 1 type to be saved.
       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;
@@ skipping 22 matching lines @@
       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);
-        // We record the names of static methods seperately so we can
+        // We record the names of static methods separately 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) {
-      if (!node.isStatic || options.emitMetadata) {
+      // Only instance fields need to be saved for dynamic dispatch.
+      var isStatic = node.isStatic;
+      if (options.emitMetadata || !isStatic) {
         for (VariableDeclaration field in node.fields.variables) {
           var element = field.element as FieldElement;
+          var fieldList = isStatic ? tStaticFields : tInstanceFields;
+
           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 fieldSig = _emitFieldSignature(element.type,
+              metadata: node.metadata, isFinal: element.isFinal);
+          fieldList.add(new JS.Property(memberName, fieldSig));
         }
       }
     }
 
     var tCtors = <JS.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));
-    }
+    _buildSignatureField(sigFields, 'constructors', tCtors);
+    _buildSignatureField(sigFields, 'fields', tInstanceFields);
+    _buildSignatureField(sigFields, 'getters', tInstanceGetters);
+    _buildSignatureField(sigFields, 'setters', tInstanceSetters);
+    _buildSignatureField(sigFields, 'methods', tInstanceMethods);
+    _buildSignatureField(sigFields, 'sfields', tStaticFields);
+    _buildSignatureField(sigFields, 'sgetters', tStaticGetters);
+    _buildSignatureField(sigFields, 'ssetters', tStaticSetters);
+    _buildSignatureField(sigFields, 'statics', tStaticMethods);
     if (!tStaticMethods.isEmpty) {
       assert(!sNames.isEmpty);
       // 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);
+      sigFields.add(new JS.Property(
+          _propertyName('names'), new JS.ArrayInitializer(sNames)));
     }
     // We set signature here, even if empty, to simplify the work of
     // defineExtensionMembers at runtime. See _defineExtensionMembers.
     if (!sigFields.isEmpty ||
         _classProperties.extensionMembers.isNotEmpty ||
         _classProperties.mixinExtensionMembers.isNotEmpty) {
       var sig = new JS.ObjectInitializer(sigFields);
       body.add(_callHelperStatement('setSignature(#, #);', [className, sig]));
     }
     // Add static property dart._runtimeType to Object.
@@ skipping 929 matching lines @@
     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.Expression _emitFieldSignature(DartType type,
+      {List<Annotation> metadata, bool isFinal: true}) {
+    var args = [_emitType(type)];
+    if (options.emitMetadata && metadata != null && metadata.isNotEmpty) {
+      args.add(new JS.ArrayInitializer(
+          metadata.map(_instantiateAnnotation).toList()));
+    }
+    return _callHelper(isFinal ? 'finalFieldType(#)' : 'fieldType(#)', args);
+  }
+
   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])
           : <Annotation>[];
       result.add(_emitAnnotatedType(types[i], metadata));
     }
@@ skipping 3160 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;
 }