| OLD | NEW |
| (Empty) |
| 1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file | |
| 2 // for details. All rights reserved. Use of this source code is governed by a | |
| 3 // BSD-style license that can be found in the LICENSE file. | |
| 4 | |
| 5 part of resolution.compute_members; | |
| 6 | |
| 7 class DeclaredMember implements Member { | |
| 8 final Name name; | |
| 9 final Element element; | |
| 10 final InterfaceType declarer; | |
| 11 final DartType type; | |
| 12 final FunctionType functionType; | |
| 13 | |
| 14 DeclaredMember(this.name, this.element, | |
| 15 this.declarer, | |
| 16 this.type, this.functionType); | |
| 17 | |
| 18 bool get isStatic => !element.isInstanceMember(); | |
| 19 | |
| 20 bool get isGetter => element.isGetter() || (!isSetter && element.isField()); | |
| 21 | |
| 22 bool get isSetter => name.isSetter; | |
| 23 | |
| 24 bool get isMethod => element.isFunction(); | |
| 25 | |
| 26 bool get isDeclaredByField => element.isField(); | |
| 27 | |
| 28 /// Returns this member as inherited from [instance]. | |
| 29 /// | |
| 30 /// For instance: | |
| 31 /// class A<T> { T m() {} } | |
| 32 /// class B<S> extends A<S> {} | |
| 33 /// class C<U> extends B<U> {} | |
| 34 /// The member `T m()` is declared in `A<T>` and inherited from `A<S>` into | |
| 35 /// `B` as `S m()`, and further from `B<U>` into `C` as `U m()`. | |
| 36 DeclaredMember inheritFrom(InterfaceType instance) { | |
| 37 // If the member is declared in a non-generic class its type cannot change | |
| 38 // as a result of inheritance. | |
| 39 if (!declarer.isGeneric) return this; | |
| 40 assert(declarer.element == instance.element); | |
| 41 return new InheritedMember(this, instance); | |
| 42 } | |
| 43 | |
| 44 Iterable<Member> get declarations => <Member>[this]; | |
| 45 | |
| 46 int get hashCode => element.hashCode + 13 * isSetter.hashCode; | |
| 47 | |
| 48 bool operator ==(other) { | |
| 49 if (other is! Member) return false; | |
| 50 return element == other.element && | |
| 51 isSetter == other.isSetter; | |
| 52 } | |
| 53 | |
| 54 String toString() { | |
| 55 StringBuffer sb = new StringBuffer(); | |
| 56 printOn(sb, type); | |
| 57 return sb.toString(); | |
| 58 } | |
| 59 | |
| 60 void printOn(StringBuffer sb, DartType type) { | |
| 61 if (isStatic) { | |
| 62 sb.write('static '); | |
| 63 } | |
| 64 if (isGetter) { | |
| 65 sb.write(type); | |
| 66 sb.write(' get '); | |
| 67 sb.write(name); | |
| 68 } else if (isSetter) { | |
| 69 sb.write('void set '); | |
| 70 sb.write(name.getter); | |
| 71 sb.write('('); | |
| 72 sb.write(type); | |
| 73 sb.write(' _)'); | |
| 74 } else { | |
| 75 sb.write(type.getStringAsDeclared('$name')); | |
| 76 } | |
| 77 } | |
| 78 } | |
| 79 | |
| 80 class InheritedMember implements DeclaredMember { | |
| 81 final DeclaredMember declaration; | |
| 82 final InterfaceType instance; | |
| 83 | |
| 84 InheritedMember(DeclaredMember this.declaration, | |
| 85 InterfaceType this.instance) { | |
| 86 assert(instance.isGeneric); | |
| 87 assert(!declaration.isStatic); | |
| 88 } | |
| 89 | |
| 90 Element get element => declaration.element; | |
| 91 | |
| 92 Name get name => declaration.name; | |
| 93 | |
| 94 InterfaceType get declarer => instance; | |
| 95 | |
| 96 bool get isStatic => false; | |
| 97 | |
| 98 bool get isSetter => declaration.isSetter; | |
| 99 | |
| 100 bool get isGetter => declaration.isGetter; | |
| 101 | |
| 102 bool get isMethod => declaration.isMethod; | |
| 103 | |
| 104 bool get isDeclaredByField => declaration.isDeclaredByField; | |
| 105 | |
| 106 DartType get type => declaration.type.substByContext(instance); | |
| 107 | |
| 108 FunctionType get functionType { | |
| 109 return declaration.functionType.substByContext(instance); | |
| 110 } | |
| 111 | |
| 112 DeclaredMember inheritFrom(InterfaceType newInstance) { | |
| 113 assert(() { | |
| 114 // Assert that if [instance] contains type variables, then these are | |
| 115 // defined in the declaration of [newInstance] and will therefore be | |
| 116 // substituted into the context of [newInstance] in the created member. | |
| 117 ClassElement contextClass = Types.getClassContext(instance); | |
| 118 return contextClass == null || contextClass == newInstance.element; | |
| 119 }); | |
| 120 return new InheritedMember(declaration, | |
| 121 instance.substByContext(newInstance)); | |
| 122 } | |
| 123 | |
| 124 Iterable<Member> get declarations => <Member>[this]; | |
| 125 | |
| 126 int get hashCode => declaration.hashCode + 17 * instance.hashCode; | |
| 127 | |
| 128 bool operator ==(other) { | |
| 129 if (other is! InheritedMember) return false; | |
| 130 return declaration == other.declaration && | |
| 131 instance == other.instance; | |
| 132 } | |
| 133 | |
| 134 void printOn(StringBuffer sb, DartType type) { | |
| 135 declaration.printOn(sb, type); | |
| 136 sb.write(' inherited from $instance'); | |
| 137 } | |
| 138 | |
| 139 String toString() { | |
| 140 StringBuffer sb = new StringBuffer(); | |
| 141 return sb.toString(); | |
| 142 } | |
| 143 } | |
| 144 | |
| 145 abstract class AbstractSyntheticMember implements MemberSignature { | |
| 146 final Set<Member> inheritedMembers; | |
| 147 | |
| 148 AbstractSyntheticMember(this.inheritedMembers); | |
| 149 | |
| 150 Member get member => inheritedMembers.first; | |
| 151 | |
| 152 Iterable<Member> get declarations => inheritedMembers; | |
| 153 | |
| 154 Name get name => member.name; | |
| 155 } | |
| 156 | |
| 157 | |
| 158 class SyntheticMember extends AbstractSyntheticMember { | |
| 159 final DartType type; | |
| 160 final FunctionType functionType; | |
| 161 | |
| 162 SyntheticMember(Set<Member> inheritedMembers, | |
| 163 this.type, | |
| 164 this.functionType) | |
| 165 : super(inheritedMembers); | |
| 166 | |
| 167 bool get isSetter => member.isSetter; | |
| 168 | |
| 169 bool get isGetter => member.isGetter; | |
| 170 | |
| 171 bool get isMethod => member.isMethod; | |
| 172 | |
| 173 bool get isErroneous => false; | |
| 174 | |
| 175 String toString() => '${type.getStringAsDeclared('$name')} synthesized ' | |
| 176 'from ${inheritedMembers}'; | |
| 177 } | |
| 178 | |
| 179 class ErroneousMember extends AbstractSyntheticMember { | |
| 180 ErroneousMember(Set<Member> inheritedMembers) : super(inheritedMembers); | |
| 181 | |
| 182 DartType get type => functionType; | |
| 183 | |
| 184 FunctionType get functionType { | |
| 185 throw new UnsupportedError('Erroneous members have no type.'); | |
| 186 } | |
| 187 | |
| 188 bool get isSetter => false; | |
| 189 | |
| 190 bool get isGetter => false; | |
| 191 | |
| 192 bool get isMethod => false; | |
| 193 | |
| 194 bool get isErroneous => true; | |
| 195 | |
| 196 String toString() => "erroneous member '$name' synthesized " | |
| 197 "from ${inheritedMembers}"; | |
| 198 } | |
| 199 | |
| OLD | NEW |