Use synthetic elements to recover from errors in signatures.dart.

dart/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 'elements.dart';
 import '../constants/expressions.dart';
 import '../helpers/helpers.dart';  // Included for debug helpers.
 import '../tree/tree.dart';
@@ skipping 1360 matching lines @@
   // TODO(ahe): Should return the definingElement of the error site?
   AstElement get definingElement => this;
 
   void reuseElement() {
     throw new UnsupportedError("reuseElement");
   }
 
   FieldElementX copyWithEnclosing(Element enclosingElement) {
     throw new UnsupportedError("copyWithEnclosing");
   }
+
+  DartType computeType(Compiler compiler) => type;

[karlklose, 2015/01/12 10:17:07]

Why do we need to add this? Do these now flow into code that does not use the
type getter?

[ahe, 2015/01/12 10:25:32]

I've identified the place that causes an exception in signatures.dart. Since
that is part of the resolver, so I don't think it is a problem that it invokes
computeType.

 }
 
 /// [Element] for a parameter-like element.
 class FormalElementX extends ElementX
     with AstElementMixin
     implements FormalElement {
   final VariableDefinitions definitions;
   final Identifier identifier;
   DartType typeCache;
 
@@ skipping 84 matching lines @@
                          Identifier identifier,
                          Expression initializer)
       : super(ElementKind.PARAMETER, functionDeclaration,
               definitions, identifier, initializer);
 }
 
 /// Parameters in constructors that directly initialize fields. For example:
 /// `A(this.field)`.
 class InitializingFormalElementX extends ParameterElementX
     implements InitializingFormalElement {
-  FieldElement fieldElement;
+  final FieldElement fieldElement;
 
   InitializingFormalElementX(ConstructorElement constructorDeclaration,
                              VariableDefinitions variables,
                              Identifier identifier,
                              Expression initializer,
                              this.fieldElement)
       : super(ElementKind.INITIALIZING_FORMAL, constructorDeclaration,
               variables, identifier, initializer);
 
   accept(ElementVisitor visitor) => visitor.visitFieldParameterElement(this);
 
   MemberElement get memberContext => enclosingElement;
 
   bool get isLocal => false;
 }
 
+class ErroneousInitializingFormalElementX extends ParameterElementX
+    implements InitializingFormalElementX {
+  final ErroneousFieldElementX fieldElement;
+
+  ErroneousInitializingFormalElementX(
+      Identifier identifier,
+      Element enclosingElement)
+      : this.fieldElement =
+            new ErroneousFieldElementX(identifier, enclosingElement),
+        super(
+            ElementKind.INITIALIZING_FORMAL,
+            enclosingElement, null, identifier, null);
+
+  VariableDefinitions get definitions => fieldElement.node;
+
+  MemberElement get memberContext => enclosingElement;
+
+  bool get isLocal => false;
+
+  bool get isErroneous => true;
+
+  DynamicType get type => const DynamicType();
+}
 
 class AbstractFieldElementX extends ElementX implements AbstractFieldElement {
   FunctionElementX getter;
   FunctionElementX setter;
 
   AbstractFieldElementX(String name, Element enclosing)
       : super(name, ElementKind.ABSTRACT_FIELD, enclosing);
 
   DartType computeType(Compiler compiler) {
     throw "internal error: AbstractFieldElement has no type";
@@ skipping 1426 matching lines @@
   AstElement get definingElement;
 
   bool get hasResolvedAst => definingElement.hasTreeElements;
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(declaration,
         definingElement.node, definingElement.treeElements);
   }
 
 }