Additional fixes for invalid overrides in dart2js

pkg/compiler/lib/src/elements/modelx.dart

 // Copyright (c) 2013, 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.
 
 library elements.modelx;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers;
 import '../common/resolution.dart' show Resolution, ParsingContext;
 import '../compiler.dart' show Compiler;
@@ skipping 232 matching lines @@
   Iterable<MetadataAnnotation> get metadata => unsupported();
   bool get hasNode => false;
   get node => unsupported();
   get hasResolvedAst => false;
   get resolvedAst => unsupported();
   get type => unsupported();
   get cachedNode => unsupported();
   get functionSignature => unsupported();
   get parameterStructure => unsupported();
   get parameters => unsupported();
-  Element get patch => null;
-  Element get origin => this;
+  FunctionElement get patch => null;
+  FunctionElement get origin => this;
   get immediateRedirectionTarget => unsupported();
   get nestedClosures => unsupported();
   get memberContext => unsupported();
   get executableContext => unsupported();
   get isExternal => unsupported();
   get constantConstructor => null;
 
   bool get isRedirectingGenerative => unsupported();
   bool get isRedirectingFactory => unsupported();
 
@@ skipping 3282 matching lines @@
 
   bool get hasNode => true;
 
   Metadata get node => metadata;
 }
 
 /// Mixin for the implementation of patched elements.
 ///
 /// See `patch_parser.dart` for a description of the terminology.
 abstract class PatchMixin<E extends Element> implements Element {
-  // TODO(johnniwinther): Use type variables.
-  Element /* E */ patch = null;
-  Element /* E */ origin = null;
+  E patch = null;
+  E origin = null;
 
   bool get isPatch => origin != null;
   bool get isPatched => patch != null;
 
   bool get isImplementation => !isPatched;
   bool get isDeclaration => !isPatch;
 
-  Element /* E */ get implementation => isPatched ? patch : this;
-  Element /* E */ get declaration => isPatch ? origin : this;
+  E get implementation => isPatched ? patch : this;
+  E get declaration => isPatch ? origin : this;
 
   /// Applies a patch to this element. This method must be called at most once.
   void applyPatch(PatchMixin<E> patch) {
     assert(this.patch == null, failedAt(this, "Element is patched twice."));
     assert(this.origin == null, failedAt(this, "Origin element is a patch."));
     assert(patch.origin == null, failedAt(patch, "Element is patched twice."));
     assert(patch.patch == null, failedAt(patch, "Patch element is patched."));
+    // ignore: INVALID_ASSIGNMENT
     this.patch = patch;

[Siggi Cherem (dart-lang), 2017/07/24 23:02:23]

the alternative is to add `as E` here. I might want to do that separately to
measure the impact on golem. This code is anyways going to be deleted in the
long run... 

+    // ignore: INVALID_ASSIGNMENT
     patch.origin = this;
   }
 }
 
 /// Abstract implementation of the [AstElement] interface.
 abstract class AstElementMixin implements AstElement {
   /// The element whose node defines this element.
   ///
   /// For patched functions the defining element is the patch element found
   /// through [implementation] since its node define the implementation of the
@@ skipping 17 matching lines @@
       body = node.asFunctionExpression().body;
     }
     return new ParsedResolvedAst(
         declaration,
         node,
         body,
         definingElement.treeElements,
         definingElement.compilationUnit.script.resourceUri);
   }
 }