Add erroneous elements for function types and use them to allow unresolvable constructors to be han…

lib/compiler/implementation/elements/elements.dart

 // Copyright (c) 2012, 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');
 
 #import('dart:uri');
 
 #import('../tree/tree.dart');
 #import('../scanner/scannerlib.dart');
@@ skipping 142 matching lines @@
   bool isTypeVariable() => kind === ElementKind.TYPE_VARIABLE;
   bool isField() => kind === ElementKind.FIELD;
   bool isGetter() => kind === ElementKind.GETTER;
   bool isSetter() => kind === ElementKind.SETTER;
   bool isAccessor() => isGetter() || isSetter();
   bool isForeign() => kind === ElementKind.FOREIGN;
   bool isLibrary() => kind === ElementKind.LIBRARY;
   bool impliesType() => (kind.category & ElementCategory.IMPLIES_TYPE) != 0;
   bool isExtendable() => (kind.category & ElementCategory.IS_EXTENDABLE) != 0;
 
+  /** See [ErroneousElement] for documentation. */
+  bool isValid() => true;

[ahe, 2012/08/20 15:06:47]

How about isErroneous instead (and reversed).

[karlklose, 2012/08/21 11:44:10]

Done.

+
   // TODO(johnniwinther): This breaks for libraries (for which enclosing
   // elements are null) and is invalid for top level variable declarations for
   // which the enclosing element is a VariableDeclarations and not a compilation
   // unit.
   bool isTopLevel() {
     return enclosingElement !== null && enclosingElement.isCompilationUnit();
   }
 
   bool isAssignable() {
     if (modifiers != null && modifiers.isFinal()) return false;
@@ skipping 107 matching lines @@
 
   FunctionElement asFunctionElement() => null;
 
   Element cloneTo(Element enclosing, DiagnosticListener listener) {
     listener.cancel("Unimplemented cloneTo", element: this);
   }
 
   Link<Type> get allSupertypesAndSelf() {
     return allSupertypes.prepend(new InterfaceType(this));
   }
+
+  static bool isInvalid(Element e) => e == null || !e.isValid();
+}
+
+/**
+ * [ErroneousElement]s are used to mark something as unresolvable, but in

[ahe, 2012/08/20 15:06:47]

Try to keep the first line a summary of the class without referring to the
class' own name. Eventually, apidoc should be able to generate a summary of
classes that use the first paragraph like this:

ErroneousElement: Fist paragraph goes here.

With this documentation comment, the summary becomes:

ErroneousElement: [ErroneousElement]s are used to mark something as
unresolvable, but in contrast to using [null], there is additional information
about the error that caused the element to be unresolvable.

Notice how the name is repeated, and that the "summary" contains motivation.

[karlklose, 2012/08/21 11:44:10]

Done.

+ * contrast to using [null], there is additional information about the error
+ * that caused the element to be unresolvable.
+ *
+ * Accessing any field or calling any method defined on [Element] except
+ * [isValid] will throw an exception.

[ahe, 2012/08/20 15:06:47]

I don't think that is a good idea.

[karlklose, 2012/08/21 11:44:10]

On 2012/08/20 15:06:47, ahe wrote:
I added a comment saying that we might some of these properties to also have
meaning for erroneous elements.

+ *
+ * Code that does not handle [ErroneousElement]s should use
+ *   [Element.isInvalid(element)]

[ahe, 2012/08/20 15:06:47]

[: Element.isInvalid(element) :]

[karlklose, 2012/08/21 11:44:10]

Done.

+ * to check for unresolvable elements instead of
+ *   [element == null].

[ahe, 2012/08/20 15:06:47]

[: element == null :]

[karlklose, 2012/08/21 11:44:10]

Done.

+ */
+class ErroneousElement extends Element {
+  final Message errorMessage;
+
+  ErroneousElement(this.errorMessage, Element enclosing)
+      : super(const SourceString('erroneous element'), null, enclosing);
+
+  isValid() => false;
+
+  unsupported() {
+    throw 'unsupported operation on erroneous element';
+  }
+
+  SourceString get name() => unsupported();
+  ElementKind get kind() => unsupported();
+  Link<Node> get metadata() => unsupported();
+}
+
+class ErroneousFunctionElement extends ErroneousElement
+                               implements FunctionElement {
+  ErroneousFunctionElement(errorMessage, Element enclosing)
+      : super(errorMessage, enclosing);
+
+  get type() => unsupported();
+  get cachedNode() => unsupported();
+  get functionSignature() => unsupported();
+  get patch() => unsupported();
+  get defaultImplementation() => unsupported();
+  bool get isPatched() => unsupported();
+  setPatch(patch) => unsupported();
+  computeSignature(compiler) => unsupported();
+  requiredParameterCount(compiler) => unsupported();
+  optionalParameterCount(compiler) => unsupported();
+  parameterCount(copmiler) => unsupported();
 }
 
 class ContainerElement extends Element {
   Link<Element> localMembers = const EmptyLink<Element>();
 
   ContainerElement(name, kind, enclosingElement)
     : super(name, kind, enclosingElement);
 
   void addMember(Element element, DiagnosticListener listener) {
     localMembers = localMembers.prepend(element);
@@ skipping 986 matching lines @@
   Scope buildScope() =>
       new ClassScope(enclosingElement.buildScope(), this);
 
   ClassElement cloneTo(Element enclosing, DiagnosticListener listener) {
     listener.internalErrorOnElement(this, 'unsupported operation');
   }
 }
 
 class Elements {
   static bool isLocal(Element element) {
-    return ((element !== null)
+    return !Element.isInvalid(element)
             && !element.isInstanceMember()
             && !isStaticOrTopLevelField(element)
             && !isStaticOrTopLevelFunction(element)
             && (element.kind === ElementKind.VARIABLE ||
                 element.kind === ElementKind.PARAMETER ||
-                element.kind === ElementKind.FUNCTION));
+                element.kind === ElementKind.FUNCTION);
   }
 
   static bool isInstanceField(Element element) {
-    return (element !== null)
+    return !Element.isInvalid(element)
            && element.isInstanceMember()
            && (element.kind === ElementKind.FIELD
                || element.kind === ElementKind.GETTER
                || element.kind === ElementKind.SETTER);
   }
 
   static bool isStaticOrTopLevel(Element element) {
-    return (element != null)
+    return !Element.isInvalid(element)
            && !element.isInstanceMember()
            && !element.isPrefix()
            && element.enclosingElement !== null
            && (element.enclosingElement.kind == ElementKind.CLASS ||
                element.enclosingElement.kind == ElementKind.COMPILATION_UNIT ||
                element.enclosingElement.kind == ElementKind.LIBRARY);
   }
 
   static bool isStaticOrTopLevelField(Element element) {
     return isStaticOrTopLevel(element)
            && (element.kind === ElementKind.FIELD
                || element.kind === ElementKind.GETTER
                || element.kind === ElementKind.SETTER);
   }
 
   static bool isStaticOrTopLevelFunction(Element element) {
     return isStaticOrTopLevel(element)
            && (element.kind === ElementKind.FUNCTION);
   }
 
   static bool isInstanceMethod(Element element) {
-    return (element != null)
+    return !Element.isInvalid(element)
            && element.isInstanceMember()
            && (element.kind === ElementKind.FUNCTION);
   }
 
   static bool isInstanceSend(Send send, TreeElements elements) {
     Element element = elements[send];
     if (element === null) return !isClosureSend(send, element);
     return isInstanceMethod(element) || isInstanceField(element);
   }
 
@@ skipping 132 matching lines @@
   Node parseNode(compiler) => cachedNode;
 
   String toString() => "${enclosingElement.toString()}.${name.slowToString()}";
 
   TypeVariableElement cloneTo(Element enclosing, DiagnosticListener listener) {
     TypeVariableElement result =
         new TypeVariableElement(name, enclosing, node, type, bound);
     return result;
   }
 }