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