OLD | NEW |
(Empty) | |
| 1 // Copyright (c) 2016, 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 library fasta.analyzer.element_store; |
| 6 |
| 7 import 'package:kernel/analyzer/loader.dart' show |
| 8 ReferenceLevelLoader; |
| 9 |
| 10 import 'package:kernel/ast.dart'; |
| 11 |
| 12 import 'package:analyzer/analyzer.dart' show |
| 13 ParameterKind; |
| 14 |
| 15 import 'package:analyzer/analyzer.dart' as analyzer; |
| 16 |
| 17 import 'package:analyzer/dart/element/element.dart'; |
| 18 |
| 19 import 'package:analyzer/dart/element/type.dart' as analyzer; |
| 20 |
| 21 import '../errors.dart' show |
| 22 internalError; |
| 23 |
| 24 import '../kernel/kernel_builder.dart'; |
| 25 |
| 26 import '../dill/dill_member_builder.dart'; |
| 27 |
| 28 import 'mock_element.dart'; |
| 29 |
| 30 import 'mock_type.dart'; |
| 31 |
| 32 abstract class ElementStore implements ReferenceLevelLoader { |
| 33 Element operator[] (Builder builder); |
| 34 |
| 35 factory ElementStore( |
| 36 LibraryBuilder coreLibrary, Map<Uri, LibraryBuilder> builders) = |
| 37 ElementStoreImplementation; |
| 38 } |
| 39 |
| 40 // ClassElement, |
| 41 // ClassMemberElement, |
| 42 // CompilationUnitElement, |
| 43 // ConstructorElement, |
| 44 // Element, |
| 45 // FieldElement, |
| 46 // FieldFormalParameterElement, |
| 47 // FunctionElement, |
| 48 // FunctionTypedElement, |
| 49 // LibraryElement, |
| 50 // LocalElement, |
| 51 // LocalVariableElement, |
| 52 // MethodElement, |
| 53 // ParameterElement, |
| 54 // PrefixElement, |
| 55 // PropertyAccessorElement, |
| 56 // TopLevelVariableElement, |
| 57 // TypeParameterElement, |
| 58 // VariableElement; |
| 59 class ElementStoreImplementation implements ElementStore { |
| 60 final LibraryBuilder coreLibrary; |
| 61 |
| 62 final Map<Builder, Element> elements; |
| 63 |
| 64 ElementStoreImplementation.internal(this.coreLibrary, this.elements); |
| 65 |
| 66 Element operator[] (Builder builder) { |
| 67 // Avoid storing local elements in the element store to reduce memory |
| 68 // usage. So they both implement [Element] and [Builder]. |
| 69 return builder is Element ? builder : elements[builder]; |
| 70 } |
| 71 |
| 72 factory ElementStoreImplementation( |
| 73 LibraryBuilder coreLibrary, Map<Uri, LibraryBuilder> libraries) { |
| 74 Map<Builder, Element> elements = <Builder, Element>{}; |
| 75 libraries.forEach((Uri uri, LibraryBuilder library) { |
| 76 KernelCompilationUnitElement unit = |
| 77 new KernelCompilationUnitElement(library); |
| 78 KernelLibraryElement element = new KernelLibraryElement(unit); |
| 79 elements[library] = element; |
| 80 unit.library = element; |
| 81 library.members.forEach((String name, Builder builder) { |
| 82 do { |
| 83 if (builder is ClassBuilder) { |
| 84 elements[builder] = new KernelClassElement(builder); |
| 85 } else if (builder is DillMemberBuilder) { |
| 86 Member member = builder.member; |
| 87 if (member is Field) { |
| 88 } else if (member is Procedure) { |
| 89 buildDillFunctionElement(builder, unit, elements); |
| 90 } else { |
| 91 internalError("Unhandled $name ${member.runtimeType} in $uri"); |
| 92 } |
| 93 } else if (builder is KernelProcedureBuilder) { |
| 94 buildKernelFunctionElement(builder, unit, elements); |
| 95 } else { |
| 96 internalError("Unhandled $name ${builder.runtimeType} in $uri"); |
| 97 } |
| 98 builder = builder.next; |
| 99 } while (builder != null); |
| 100 }); |
| 101 }); |
| 102 return new ElementStoreImplementation.internal(coreLibrary, elements); |
| 103 } |
| 104 |
| 105 bool get ignoreRedirectingFactories => false; |
| 106 |
| 107 Constructor getCoreClassConstructorReference(String className, |
| 108 {String constructorName, String library}) { |
| 109 assert(library == null); |
| 110 KernelClassBuilder cls = coreLibrary.members[className]; |
| 111 Constructor constructor = constructorName == null |
| 112 ? cls.cls.constructors.first |
| 113 : cls.cls.constructors.firstWhere( |
| 114 (Constructor c) => c.name.name == constructorName); |
| 115 return constructor; |
| 116 } |
| 117 |
| 118 Library getLibraryReference(LibraryElement element) { |
| 119 return internalError("not supported."); |
| 120 } |
| 121 |
| 122 Class getClassReference(KernelClassElement cls) => cls.builder.cls; |
| 123 |
| 124 Member getMemberReference(Element element) { |
| 125 if (element is KernelFunctionElement) { |
| 126 return element.procedure; |
| 127 } else { |
| 128 return internalError("getMemberReference(${element.runtimeType})"); |
| 129 } |
| 130 } |
| 131 |
| 132 Class getRootClassReference() => internalError("not supported."); |
| 133 |
| 134 Constructor getRootClassConstructorReference() { |
| 135 return internalError("not supported."); |
| 136 } |
| 137 |
| 138 Class getCoreClassReference(String className) { |
| 139 return internalError("not supported."); |
| 140 } |
| 141 |
| 142 TypeParameter tryGetClassTypeParameter(TypeParameterElement element) { |
| 143 return internalError("not supported."); |
| 144 } |
| 145 |
| 146 Class getSharedMixinApplicationClass( |
| 147 Library library, Class supertype, Class mixin) { |
| 148 return internalError("not supported."); |
| 149 } |
| 150 |
| 151 bool get strongMode => false; |
| 152 |
| 153 static void buildDillFunctionElement(DillMemberBuilder builder, |
| 154 KernelCompilationUnitElement unit, Map<Builder, Element> elements) { |
| 155 Procedure procedure = builder.member; |
| 156 List<VariableDeclaration> positionalParameters = |
| 157 procedure.function.positionalParameters; |
| 158 List<VariableDeclaration> namedParameters = |
| 159 procedure.function.namedParameters; |
| 160 int requiredParameterCount = procedure.function.requiredParameterCount; |
| 161 List<KernelParameterElement> parameters = new List<KernelParameterElement>( |
| 162 positionalParameters.length + namedParameters.length); |
| 163 int i = 0; |
| 164 for (VariableDeclaration parameter in positionalParameters) { |
| 165 parameters[i] = buildFormalParameter( |
| 166 parameter, isOptional: i >= requiredParameterCount); |
| 167 i++; |
| 168 } |
| 169 for (VariableDeclaration parameter in namedParameters) { |
| 170 parameters[i++] = buildFormalParameter(parameter, isNamed: true); |
| 171 } |
| 172 elements[builder] = new KernelFunctionElement(procedure, unit, parameters); |
| 173 } |
| 174 |
| 175 static void buildKernelFunctionElement(KernelProcedureBuilder builder, |
| 176 KernelCompilationUnitElement unit, Map<Builder, Element> elements) { |
| 177 assert(builder.procedure != null); |
| 178 List<KernelParameterElement> parameters; |
| 179 int i = 0; |
| 180 if (builder.formals != null) { |
| 181 parameters = new List<KernelParameterElement>(builder.formals.length); |
| 182 for (KernelFormalParameterBuilder parameter in builder.formals) { |
| 183 assert(parameter.declaration != null); |
| 184 elements[parameter] = parameters[i++] = buildFormalParameter( |
| 185 parameter.declaration, isOptional: parameter.isOptional, |
| 186 isNamed: parameter.isNamed); |
| 187 } |
| 188 } else { |
| 189 parameters = new List<KernelParameterElement>(0); |
| 190 } |
| 191 elements[builder] = new KernelFunctionElement( |
| 192 builder.procedure, unit, parameters); |
| 193 } |
| 194 |
| 195 static KernelParameterElement buildFormalParameter( |
| 196 VariableDeclaration parameter, |
| 197 {bool isOptional: true, bool isNamed: false}) { |
| 198 ParameterKind kind = isOptional |
| 199 ? (isNamed ? ParameterKind.NAMED : ParameterKind.POSITIONAL) |
| 200 : ParameterKind.REQUIRED; |
| 201 return new KernelParameterElement(parameter, kind); |
| 202 } |
| 203 } |
| 204 |
| 205 class KernelLibraryElement extends MockLibraryElement { |
| 206 final KernelCompilationUnitElement definingCompilationUnit; |
| 207 |
| 208 KernelLibraryElement(this.definingCompilationUnit); |
| 209 |
| 210 FunctionElement get loadLibraryFunction => null; |
| 211 } |
| 212 |
| 213 class KernelCompilationUnitElement extends MockCompilationUnitElement { |
| 214 final LibraryBuilder builder; |
| 215 |
| 216 KernelLibraryElement library; |
| 217 |
| 218 KernelCompilationUnitElement(this.builder); |
| 219 |
| 220 KernelLibraryElement get enclosingElement => library; |
| 221 |
| 222 String get uri => "${builder.uri}"; |
| 223 } |
| 224 |
| 225 class KernelFunctionElement extends MockFunctionElement { |
| 226 final Procedure procedure; |
| 227 |
| 228 final KernelCompilationUnitElement enclosingElement; |
| 229 |
| 230 final List<KernelParameterElement> parameters; |
| 231 |
| 232 KernelFunctionElement(this.procedure, this.enclosingElement, this.parameters); |
| 233 |
| 234 KernelLibraryElement get library => enclosingElement.library; |
| 235 } |
| 236 |
| 237 class KernelParameterElement extends MockParameterElement { |
| 238 final VariableDeclaration declaration; |
| 239 |
| 240 final ParameterKind parameterKind; |
| 241 |
| 242 KernelParameterElement(this.declaration, this.parameterKind); |
| 243 } |
| 244 |
| 245 /// Both an [Element] and [Builder] to using memory to store local elements in |
| 246 /// [ElementStore]. |
| 247 class AnalyzerLocalVariableElemment extends MockElement with Builder |
| 248 implements LocalVariableElement { |
| 249 final analyzer.VariableDeclaration variable; |
| 250 |
| 251 AnalyzerLocalVariableElemment(this.variable) |
| 252 : super(ElementKind.LOCAL_VARIABLE); |
| 253 |
| 254 String get name => variable.name.name; |
| 255 |
| 256 bool get isFinal => false; // TODO(ahe): implement this. |
| 257 |
| 258 bool get isConst => false; // TODO(ahe): implement this. |
| 259 |
| 260 analyzer.VariableDeclaration get target => variable; |
| 261 } |
| 262 |
| 263 /// Both an [Element] and [Builder] to using memory to store local elements in |
| 264 /// [ElementStore]. |
| 265 class AnalyzerParameterElement extends MockParameterElement with Builder { |
| 266 final analyzer.FormalParameter parameter; |
| 267 |
| 268 AnalyzerParameterElement(this.parameter); |
| 269 |
| 270 String get name => parameter.identifier.name; |
| 271 |
| 272 bool get isFinal => false; // TODO(ahe): implement this. |
| 273 |
| 274 bool get isConst => false; // TODO(ahe): implement this. |
| 275 |
| 276 analyzer.FormalParameter get target => parameter; |
| 277 } |
| 278 |
| 279 class KernelClassElement extends MockClassElement { |
| 280 final KernelClassBuilder builder; |
| 281 |
| 282 KernelInterfaceType rawType; |
| 283 |
| 284 KernelClassElement(this.builder) { |
| 285 rawType = new KernelInterfaceType(this); |
| 286 } |
| 287 } |
| 288 |
| 289 class KernelInterfaceType extends MockInterfaceType { |
| 290 final KernelClassElement element; |
| 291 |
| 292 KernelInterfaceType(this.element); |
| 293 |
| 294 List<analyzer.DartType> get typeArguments => const <analyzer.DartType>[]; |
| 295 } |
OLD | NEW |