Reapply "Implement new model for class members." and "Implement new model for interface members."

sdk/lib/_internal/compiler/implementation/resolution/member_impl.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.
+
+part of resolution.compute_members;
+
+class DeclaredMember implements Member {
+  final Name name;
+  final Element element;
+  final InterfaceType declarer;
+  final DartType type;
+  final FunctionType functionType;
+
+  DeclaredMember(this.name, this.element,
+                    this.declarer,
+                    this.type, this.functionType);
+
+  bool get isStatic => !element.isInstanceMember();
+
+  bool get isGetter => element.isGetter() || (!isSetter && element.isField());
+
+  bool get isSetter => name.isSetter;
+
+  bool get isMethod => element.isFunction();
+
+  bool get isDeclaredByField => element.isField();
+
+  /// Returns this member as inherited from [instance].
+  ///
+  /// For instance:
+  ///   class A<T> { T m() {} }
+  ///   class B<S> extends A<S> {}
+  ///   class C<U> extends B<U> {}
+  /// The member `T m()` is declared in `A<T>` and inherited from `A<S>` into
+  /// `B` as `S m()`, and further from `B<U>` into `C` as `U m()`.
+  DeclaredMember inheritFrom(InterfaceType instance) {
+    // If the member is declared in a non-generic class its type cannot change
+    // as a result of inheritance.
+    if (!declarer.isGeneric) return this;
+    assert(declarer.element == instance.element);
+    return new InheritedMember(this, instance);
+  }
+
+  Iterable<Member> get declarations => <Member>[this];
+
+  int get hashCode => element.hashCode + 13 * isSetter.hashCode;
+
+  bool operator ==(other) {
+    if (other is! Member) return false;
+    return element == other.element &&
+           isSetter == other.isSetter;
+  }
+
+  String toString() {
+    StringBuffer sb = new StringBuffer();
+    printOn(sb, type);
+    return sb.toString();
+  }
+
+  void printOn(StringBuffer sb, DartType type) {
+    if (isStatic) {
+      sb.write('static ');
+    }
+    if (isGetter) {
+      sb.write(type);
+      sb.write(' get ');
+      sb.write(name);
+    } else if (isSetter) {
+      sb.write('void set ');
+      sb.write(name.getter);
+      sb.write('(');
+      sb.write(type);
+      sb.write(' _)');
+    } else {
+      sb.write(type.getStringAsDeclared('$name'));
+    }
+  }
+}
+
+class InheritedMember implements DeclaredMember {
+  final DeclaredMember declaration;
+  final InterfaceType instance;
+
+  InheritedMember(DeclaredMember this.declaration,
+                  InterfaceType this.instance) {
+    assert(instance.isGeneric);
+    assert(!declaration.isStatic);
+  }
+
+  Element get element => declaration.element;
+
+  Name get name => declaration.name;
+
+  InterfaceType get declarer => instance;
+
+  bool get isStatic => false;
+
+  bool get isSetter => declaration.isSetter;
+
+  bool get isGetter => declaration.isGetter;
+
+  bool get isMethod => declaration.isMethod;
+
+  bool get isDeclaredByField => declaration.isDeclaredByField;
+
+  DartType get type => declaration.type.substByContext(instance);
+
+  FunctionType get functionType {
+    return declaration.functionType.substByContext(instance);
+  }
+
+  DeclaredMember inheritFrom(InterfaceType newInstance) {
+    assert(() {
+      // Assert that if [instance] contains type variables, then these are
+      // defined in the declaration of [newInstance] and will therefore be
+      // substituted into the context of [newInstance] in the created member.
+      ClassElement contextClass = Types.getClassContext(instance);
+      return contextClass == null || contextClass == newInstance.element;
+    });
+    return new InheritedMember(declaration,
+                               instance.substByContext(newInstance));
+  }
+
+  Iterable<Member> get declarations => <Member>[this];
+
+  int get hashCode => declaration.hashCode + 17 * instance.hashCode;
+
+  bool operator ==(other) {
+    if (other is! InheritedMember) return false;
+    return declaration == other.declaration &&
+           instance == other.instance;
+  }
+
+  void printOn(StringBuffer sb, DartType type) {
+    declaration.printOn(sb, type);
+    sb.write(' inherited from $instance');
+  }
+
+  String toString() {
+    StringBuffer sb = new StringBuffer();
+    return sb.toString();
+  }
+}
+
+abstract class AbstractSyntheticMember implements MemberSignature {
+  final Set<Member> inheritedMembers;
+
+  AbstractSyntheticMember(this.inheritedMembers);
+
+  Member get member => inheritedMembers.first;
+
+  Iterable<Member> get declarations => inheritedMembers;
+
+  Name get name => member.name;
+}
+
+
+class SyntheticMember extends AbstractSyntheticMember {
+  final DartType type;
+  final FunctionType functionType;
+
+  SyntheticMember(Set<Member> inheritedMembers,
+                  this.type,
+                  this.functionType)
+      : super(inheritedMembers);
+
+  bool get isSetter => member.isSetter;
+
+  bool get isGetter => member.isGetter;
+
+  bool get isMethod => member.isMethod;
+
+  bool get isErroneous => false;
+
+  String toString() => '${type.getStringAsDeclared('$name')} synthesized '
+                       'from ${inheritedMembers}';
+}
+
+class ErroneousMember extends AbstractSyntheticMember {
+  ErroneousMember(Set<Member> inheritedMembers) : super(inheritedMembers);
+
+  DartType get type => functionType;
+
+  FunctionType get functionType {
+    throw new UnsupportedError('Erroneous members have no type.');
+  }
+
+  bool get isSetter => false;
+
+  bool get isGetter => false;
+
+  bool get isMethod => false;
+
+  bool get isErroneous => true;
+
+  String toString() => "erroneous member '$name' synthesized "
+                       "from ${inheritedMembers}";
+}
+