OLD | NEW |
1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file | 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 | 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. | 3 // BSD-style license that can be found in the LICENSE file. |
4 | 4 |
5 #include "lib/mirrors.h" | 5 #include "lib/mirrors.h" |
6 | 6 |
7 #include "lib/invocation_mirror.h" | 7 #include "lib/invocation_mirror.h" |
8 #include "vm/bootstrap_natives.h" | 8 #include "vm/bootstrap_natives.h" |
9 #include "vm/class_finalizer.h" | 9 #include "vm/class_finalizer.h" |
10 #include "vm/compiler.h" | 10 #include "vm/compiler.h" |
(...skipping 20 matching lines...) Expand all Loading... |
31 const Array& constructor_arguments) { | 31 const Array& constructor_arguments) { |
32 const Library& mirrors_lib = Library::Handle(Library::MirrorsLibrary()); | 32 const Library& mirrors_lib = Library::Handle(Library::MirrorsLibrary()); |
33 const String& constructor_name = Symbols::Dot(); | 33 const String& constructor_name = Symbols::Dot(); |
34 | 34 |
35 const Object& result = Object::Handle(DartLibraryCalls::InstanceCreate( | 35 const Object& result = Object::Handle(DartLibraryCalls::InstanceCreate( |
36 mirrors_lib, mirror_class_name, constructor_name, constructor_arguments)); | 36 mirrors_lib, mirror_class_name, constructor_name, constructor_arguments)); |
37 ASSERT(!result.IsError()); | 37 ASSERT(!result.IsError()); |
38 return Instance::Cast(result).raw(); | 38 return Instance::Cast(result).raw(); |
39 } | 39 } |
40 | 40 |
41 | |
42 // Conventions: | 41 // Conventions: |
43 // * For throwing a NSM in a class klass we use its runtime type as receiver, | 42 // * For throwing a NSM in a class klass we use its runtime type as receiver, |
44 // i.e., klass.RareType(). | 43 // i.e., klass.RareType(). |
45 // * For throwing a NSM in a library, we just pass the null instance as | 44 // * For throwing a NSM in a library, we just pass the null instance as |
46 // receiver. | 45 // receiver. |
47 static void ThrowNoSuchMethod(const Instance& receiver, | 46 static void ThrowNoSuchMethod(const Instance& receiver, |
48 const String& function_name, | 47 const String& function_name, |
49 const Function& function, | 48 const Function& function, |
50 const Array& arguments, | 49 const Array& arguments, |
51 const Array& argument_names, | 50 const Array& argument_names, |
(...skipping 23 matching lines...) Expand all Loading... |
75 Class::Handle(libcore.LookupClass(Symbols::NoSuchMethodError())); | 74 Class::Handle(libcore.LookupClass(Symbols::NoSuchMethodError())); |
76 const Function& throwNew = Function::Handle( | 75 const Function& throwNew = Function::Handle( |
77 NoSuchMethodError.LookupFunctionAllowPrivate(Symbols::ThrowNew())); | 76 NoSuchMethodError.LookupFunctionAllowPrivate(Symbols::ThrowNew())); |
78 const Object& result = | 77 const Object& result = |
79 Object::Handle(DartEntry::InvokeFunction(throwNew, args)); | 78 Object::Handle(DartEntry::InvokeFunction(throwNew, args)); |
80 ASSERT(result.IsError()); | 79 ASSERT(result.IsError()); |
81 Exceptions::PropagateError(Error::Cast(result)); | 80 Exceptions::PropagateError(Error::Cast(result)); |
82 UNREACHABLE(); | 81 UNREACHABLE(); |
83 } | 82 } |
84 | 83 |
85 | |
86 static void EnsureConstructorsAreCompiled(const Function& func) { | 84 static void EnsureConstructorsAreCompiled(const Function& func) { |
87 // Only generative constructors can have initializing formals. | 85 // Only generative constructors can have initializing formals. |
88 if (!func.IsGenerativeConstructor()) return; | 86 if (!func.IsGenerativeConstructor()) return; |
89 | 87 |
90 Thread* thread = Thread::Current(); | 88 Thread* thread = Thread::Current(); |
91 Zone* zone = thread->zone(); | 89 Zone* zone = thread->zone(); |
92 const Class& cls = Class::Handle(zone, func.Owner()); | 90 const Class& cls = Class::Handle(zone, func.Owner()); |
93 const Error& error = Error::Handle(zone, cls.EnsureIsFinalized(thread)); | 91 const Error& error = Error::Handle(zone, cls.EnsureIsFinalized(thread)); |
94 if (!error.IsNull()) { | 92 if (!error.IsNull()) { |
95 Exceptions::PropagateError(error); | 93 Exceptions::PropagateError(error); |
(...skipping 94 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
190 args.SetAt(6, is_final); | 188 args.SetAt(6, is_final); |
191 args.SetAt(7, default_value); | 189 args.SetAt(7, default_value); |
192 args.SetAt(8, metadata); | 190 args.SetAt(8, metadata); |
193 param ^= CreateMirror(Symbols::_LocalParameterMirror(), args); | 191 param ^= CreateMirror(Symbols::_LocalParameterMirror(), args); |
194 results.SetAt(i, param); | 192 results.SetAt(i, param); |
195 } | 193 } |
196 results.MakeImmutable(); | 194 results.MakeImmutable(); |
197 return results.raw(); | 195 return results.raw(); |
198 } | 196 } |
199 | 197 |
200 | |
201 static RawInstance* CreateTypeVariableMirror(const TypeParameter& param, | 198 static RawInstance* CreateTypeVariableMirror(const TypeParameter& param, |
202 const Instance& owner_mirror) { | 199 const Instance& owner_mirror) { |
203 const Array& args = Array::Handle(Array::New(3)); | 200 const Array& args = Array::Handle(Array::New(3)); |
204 args.SetAt(0, param); | 201 args.SetAt(0, param); |
205 args.SetAt(1, String::Handle(param.name())); | 202 args.SetAt(1, String::Handle(param.name())); |
206 args.SetAt(2, owner_mirror); | 203 args.SetAt(2, owner_mirror); |
207 return CreateMirror(Symbols::_LocalTypeVariableMirror(), args); | 204 return CreateMirror(Symbols::_LocalTypeVariableMirror(), args); |
208 } | 205 } |
209 | 206 |
210 | |
211 // We create a list in native code and let Dart code create the type mirror | 207 // We create a list in native code and let Dart code create the type mirror |
212 // object and the ordered map. | 208 // object and the ordered map. |
213 static RawInstance* CreateTypeVariableList(const Class& cls) { | 209 static RawInstance* CreateTypeVariableList(const Class& cls) { |
214 const TypeArguments& args = TypeArguments::Handle(cls.type_parameters()); | 210 const TypeArguments& args = TypeArguments::Handle(cls.type_parameters()); |
215 if (args.IsNull()) { | 211 if (args.IsNull()) { |
216 return Object::empty_array().raw(); | 212 return Object::empty_array().raw(); |
217 } | 213 } |
218 const Array& result = Array::Handle(Array::New(args.Length() * 2)); | 214 const Array& result = Array::Handle(Array::New(args.Length() * 2)); |
219 TypeParameter& type = TypeParameter::Handle(); | 215 TypeParameter& type = TypeParameter::Handle(); |
220 String& name = String::Handle(); | 216 String& name = String::Handle(); |
221 for (intptr_t i = 0; i < args.Length(); i++) { | 217 for (intptr_t i = 0; i < args.Length(); i++) { |
222 type ^= args.TypeAt(i); | 218 type ^= args.TypeAt(i); |
223 ASSERT(type.IsTypeParameter()); | 219 ASSERT(type.IsTypeParameter()); |
224 PROPAGATE_IF_MALFORMED(type); | 220 PROPAGATE_IF_MALFORMED(type); |
225 ASSERT(type.IsFinalized()); | 221 ASSERT(type.IsFinalized()); |
226 name ^= type.name(); | 222 name ^= type.name(); |
227 result.SetAt(2 * i, name); | 223 result.SetAt(2 * i, name); |
228 result.SetAt(2 * i + 1, type); | 224 result.SetAt(2 * i + 1, type); |
229 } | 225 } |
230 return result.raw(); | 226 return result.raw(); |
231 } | 227 } |
232 | 228 |
233 | |
234 static RawInstance* CreateTypedefMirror(const Class& cls, | 229 static RawInstance* CreateTypedefMirror(const Class& cls, |
235 const AbstractType& type, | 230 const AbstractType& type, |
236 const Bool& is_declaration, | 231 const Bool& is_declaration, |
237 const Instance& owner_mirror) { | 232 const Instance& owner_mirror) { |
238 const Array& args = Array::Handle(Array::New(6)); | 233 const Array& args = Array::Handle(Array::New(6)); |
239 args.SetAt(0, MirrorReference::Handle(MirrorReference::New(cls))); | 234 args.SetAt(0, MirrorReference::Handle(MirrorReference::New(cls))); |
240 args.SetAt(1, type); | 235 args.SetAt(1, type); |
241 args.SetAt(2, String::Handle(cls.Name())); | 236 args.SetAt(2, String::Handle(cls.Name())); |
242 args.SetAt(3, Bool::Get(cls.IsGeneric())); | 237 args.SetAt(3, Bool::Get(cls.IsGeneric())); |
243 args.SetAt(4, cls.IsGeneric() ? is_declaration : Bool::False()); | 238 args.SetAt(4, cls.IsGeneric() ? is_declaration : Bool::False()); |
244 args.SetAt(5, owner_mirror); | 239 args.SetAt(5, owner_mirror); |
245 return CreateMirror(Symbols::_LocalTypedefMirror(), args); | 240 return CreateMirror(Symbols::_LocalTypedefMirror(), args); |
246 } | 241 } |
247 | 242 |
248 | |
249 static RawInstance* CreateFunctionTypeMirror(const AbstractType& type) { | 243 static RawInstance* CreateFunctionTypeMirror(const AbstractType& type) { |
250 ASSERT(type.IsFunctionType()); | 244 ASSERT(type.IsFunctionType()); |
251 const Class& cls = Class::Handle(Type::Cast(type).type_class()); | 245 const Class& cls = Class::Handle(Type::Cast(type).type_class()); |
252 const Function& func = Function::Handle(Type::Cast(type).signature()); | 246 const Function& func = Function::Handle(Type::Cast(type).signature()); |
253 const Array& args = Array::Handle(Array::New(3)); | 247 const Array& args = Array::Handle(Array::New(3)); |
254 args.SetAt(0, MirrorReference::Handle(MirrorReference::New(cls))); | 248 args.SetAt(0, MirrorReference::Handle(MirrorReference::New(cls))); |
255 args.SetAt(1, MirrorReference::Handle(MirrorReference::New(func))); | 249 args.SetAt(1, MirrorReference::Handle(MirrorReference::New(func))); |
256 args.SetAt(2, type); | 250 args.SetAt(2, type); |
257 return CreateMirror(Symbols::_LocalFunctionTypeMirror(), args); | 251 return CreateMirror(Symbols::_LocalFunctionTypeMirror(), args); |
258 } | 252 } |
259 | 253 |
260 | |
261 static RawInstance* CreateMethodMirror(const Function& func, | 254 static RawInstance* CreateMethodMirror(const Function& func, |
262 const Instance& owner_mirror, | 255 const Instance& owner_mirror, |
263 const AbstractType& instantiator) { | 256 const AbstractType& instantiator) { |
264 const Array& args = Array::Handle(Array::New(6)); | 257 const Array& args = Array::Handle(Array::New(6)); |
265 args.SetAt(0, MirrorReference::Handle(MirrorReference::New(func))); | 258 args.SetAt(0, MirrorReference::Handle(MirrorReference::New(func))); |
266 | 259 |
267 String& name = String::Handle(func.name()); | 260 String& name = String::Handle(func.name()); |
268 name = String::ScrubNameRetainPrivate(name); | 261 name = String::ScrubNameRetainPrivate(name); |
269 args.SetAt(1, name); | 262 args.SetAt(1, name); |
270 args.SetAt(2, owner_mirror); | 263 args.SetAt(2, owner_mirror); |
(...skipping 11 matching lines...) Expand all Loading... |
282 ((is_ctor && func.IsGenerativeConstructor()) << Mirrors::kGenerativeCtor); | 275 ((is_ctor && func.IsGenerativeConstructor()) << Mirrors::kGenerativeCtor); |
283 kind_flags |= | 276 kind_flags |= |
284 ((is_ctor && func.is_redirecting()) << Mirrors::kRedirectingCtor); | 277 ((is_ctor && func.is_redirecting()) << Mirrors::kRedirectingCtor); |
285 kind_flags |= ((is_ctor && func.IsFactory()) << Mirrors::kFactoryCtor); | 278 kind_flags |= ((is_ctor && func.IsFactory()) << Mirrors::kFactoryCtor); |
286 kind_flags |= (func.is_external() << Mirrors::kExternal); | 279 kind_flags |= (func.is_external() << Mirrors::kExternal); |
287 args.SetAt(5, Smi::Handle(Smi::New(kind_flags))); | 280 args.SetAt(5, Smi::Handle(Smi::New(kind_flags))); |
288 | 281 |
289 return CreateMirror(Symbols::_LocalMethodMirror(), args); | 282 return CreateMirror(Symbols::_LocalMethodMirror(), args); |
290 } | 283 } |
291 | 284 |
292 | |
293 static RawInstance* CreateVariableMirror(const Field& field, | 285 static RawInstance* CreateVariableMirror(const Field& field, |
294 const Instance& owner_mirror) { | 286 const Instance& owner_mirror) { |
295 const MirrorReference& field_ref = | 287 const MirrorReference& field_ref = |
296 MirrorReference::Handle(MirrorReference::New(field)); | 288 MirrorReference::Handle(MirrorReference::New(field)); |
297 | 289 |
298 const String& name = String::Handle(field.name()); | 290 const String& name = String::Handle(field.name()); |
299 | 291 |
300 const Array& args = Array::Handle(Array::New(7)); | 292 const Array& args = Array::Handle(Array::New(7)); |
301 args.SetAt(0, field_ref); | 293 args.SetAt(0, field_ref); |
302 args.SetAt(1, name); | 294 args.SetAt(1, name); |
303 args.SetAt(2, owner_mirror); | 295 args.SetAt(2, owner_mirror); |
304 args.SetAt(3, Object::null_instance()); // Null for type. | 296 args.SetAt(3, Object::null_instance()); // Null for type. |
305 args.SetAt(4, Bool::Get(field.is_static())); | 297 args.SetAt(4, Bool::Get(field.is_static())); |
306 args.SetAt(5, Bool::Get(field.is_final())); | 298 args.SetAt(5, Bool::Get(field.is_final())); |
307 args.SetAt(6, Bool::Get(field.is_const())); | 299 args.SetAt(6, Bool::Get(field.is_const())); |
308 | 300 |
309 return CreateMirror(Symbols::_LocalVariableMirror(), args); | 301 return CreateMirror(Symbols::_LocalVariableMirror(), args); |
310 } | 302 } |
311 | 303 |
312 | |
313 static RawInstance* CreateClassMirror(const Class& cls, | 304 static RawInstance* CreateClassMirror(const Class& cls, |
314 const AbstractType& type, | 305 const AbstractType& type, |
315 const Bool& is_declaration, | 306 const Bool& is_declaration, |
316 const Instance& owner_mirror) { | 307 const Instance& owner_mirror) { |
317 if (type.IsTypeRef()) { | 308 if (type.IsTypeRef()) { |
318 AbstractType& ref_type = AbstractType::Handle(TypeRef::Cast(type).type()); | 309 AbstractType& ref_type = AbstractType::Handle(TypeRef::Cast(type).type()); |
319 ASSERT(!ref_type.IsTypeRef()); | 310 ASSERT(!ref_type.IsTypeRef()); |
320 ASSERT(ref_type.IsCanonical()); | 311 ASSERT(ref_type.IsCanonical()); |
321 return CreateClassMirror(cls, ref_type, is_declaration, owner_mirror); | 312 return CreateClassMirror(cls, ref_type, is_declaration, owner_mirror); |
322 } | 313 } |
(...skipping 18 matching lines...) Expand all Loading... |
341 } | 332 } |
342 args.SetAt(3, owner_mirror); | 333 args.SetAt(3, owner_mirror); |
343 args.SetAt(4, Bool::Get(cls.is_abstract())); | 334 args.SetAt(4, Bool::Get(cls.is_abstract())); |
344 args.SetAt(5, Bool::Get(cls.IsGeneric())); | 335 args.SetAt(5, Bool::Get(cls.IsGeneric())); |
345 args.SetAt(6, Bool::Get(cls.is_mixin_app_alias())); | 336 args.SetAt(6, Bool::Get(cls.is_mixin_app_alias())); |
346 args.SetAt(7, cls.NumTypeParameters() == 0 ? Bool::False() : is_declaration); | 337 args.SetAt(7, cls.NumTypeParameters() == 0 ? Bool::False() : is_declaration); |
347 args.SetAt(8, Bool::Get(cls.is_enum_class())); | 338 args.SetAt(8, Bool::Get(cls.is_enum_class())); |
348 return CreateMirror(Symbols::_LocalClassMirror(), args); | 339 return CreateMirror(Symbols::_LocalClassMirror(), args); |
349 } | 340 } |
350 | 341 |
351 | |
352 static RawInstance* CreateLibraryMirror(Thread* thread, const Library& lib) { | 342 static RawInstance* CreateLibraryMirror(Thread* thread, const Library& lib) { |
353 Zone* zone = thread->zone(); | 343 Zone* zone = thread->zone(); |
354 ASSERT(!lib.IsNull()); | 344 ASSERT(!lib.IsNull()); |
355 const Array& args = Array::Handle(zone, Array::New(3)); | 345 const Array& args = Array::Handle(zone, Array::New(3)); |
356 args.SetAt(0, MirrorReference::Handle(zone, MirrorReference::New(lib))); | 346 args.SetAt(0, MirrorReference::Handle(zone, MirrorReference::New(lib))); |
357 String& str = String::Handle(zone); | 347 String& str = String::Handle(zone); |
358 str = lib.name(); | 348 str = lib.name(); |
359 args.SetAt(1, str); | 349 args.SetAt(1, str); |
360 str = lib.url(); | 350 str = lib.url(); |
361 const char* censored_libraries[] = { | 351 const char* censored_libraries[] = { |
(...skipping 17 matching lines...) Expand all Loading... |
379 other_uri = other_lib.url(); | 369 other_uri = other_lib.url(); |
380 if (other_uri.Equals("dart:html")) { | 370 if (other_uri.Equals("dart:html")) { |
381 return Instance::null(); | 371 return Instance::null(); |
382 } | 372 } |
383 } | 373 } |
384 } | 374 } |
385 args.SetAt(2, str); | 375 args.SetAt(2, str); |
386 return CreateMirror(Symbols::_LocalLibraryMirror(), args); | 376 return CreateMirror(Symbols::_LocalLibraryMirror(), args); |
387 } | 377 } |
388 | 378 |
389 | |
390 static RawInstance* CreateCombinatorMirror(const Object& identifiers, | 379 static RawInstance* CreateCombinatorMirror(const Object& identifiers, |
391 bool is_show) { | 380 bool is_show) { |
392 const Array& args = Array::Handle(Array::New(2)); | 381 const Array& args = Array::Handle(Array::New(2)); |
393 args.SetAt(0, identifiers); | 382 args.SetAt(0, identifiers); |
394 args.SetAt(1, Bool::Get(is_show)); | 383 args.SetAt(1, Bool::Get(is_show)); |
395 return CreateMirror(Symbols::_LocalCombinatorMirror(), args); | 384 return CreateMirror(Symbols::_LocalCombinatorMirror(), args); |
396 } | 385 } |
397 | 386 |
398 | |
399 static RawInstance* CreateLibraryDependencyMirror(Thread* thread, | 387 static RawInstance* CreateLibraryDependencyMirror(Thread* thread, |
400 const Instance& importer, | 388 const Instance& importer, |
401 const Namespace& ns, | 389 const Namespace& ns, |
402 const LibraryPrefix& prefix, | 390 const LibraryPrefix& prefix, |
403 const bool is_import, | 391 const bool is_import, |
404 const bool is_deferred) { | 392 const bool is_deferred) { |
405 const Library& importee = Library::Handle(ns.library()); | 393 const Library& importee = Library::Handle(ns.library()); |
406 const Instance& importee_mirror = | 394 const Instance& importee_mirror = |
407 Instance::Handle(CreateLibraryMirror(thread, importee)); | 395 Instance::Handle(CreateLibraryMirror(thread, importee)); |
408 if (importee_mirror.IsNull()) { | 396 if (importee_mirror.IsNull()) { |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
446 } | 434 } |
447 args.SetAt(2, combinators); | 435 args.SetAt(2, combinators); |
448 args.SetAt(3, prefix.IsNull() ? Object::null_object() | 436 args.SetAt(3, prefix.IsNull() ? Object::null_object() |
449 : String::Handle(prefix.name())); | 437 : String::Handle(prefix.name())); |
450 args.SetAt(4, Bool::Get(is_import)); | 438 args.SetAt(4, Bool::Get(is_import)); |
451 args.SetAt(5, Bool::Get(is_deferred)); | 439 args.SetAt(5, Bool::Get(is_deferred)); |
452 args.SetAt(6, metadata); | 440 args.SetAt(6, metadata); |
453 return CreateMirror(Symbols::_LocalLibraryDependencyMirror(), args); | 441 return CreateMirror(Symbols::_LocalLibraryDependencyMirror(), args); |
454 } | 442 } |
455 | 443 |
456 | |
457 DEFINE_NATIVE_ENTRY(LibraryMirror_fromPrefix, 1) { | 444 DEFINE_NATIVE_ENTRY(LibraryMirror_fromPrefix, 1) { |
458 GET_NON_NULL_NATIVE_ARGUMENT(LibraryPrefix, prefix, | 445 GET_NON_NULL_NATIVE_ARGUMENT(LibraryPrefix, prefix, |
459 arguments->NativeArgAt(0)); | 446 arguments->NativeArgAt(0)); |
460 const Library& deferred_lib = Library::Handle(prefix.GetLibrary(0)); | 447 const Library& deferred_lib = Library::Handle(prefix.GetLibrary(0)); |
461 if (!deferred_lib.Loaded()) { | 448 if (!deferred_lib.Loaded()) { |
462 return Instance::null(); | 449 return Instance::null(); |
463 } | 450 } |
464 return CreateLibraryMirror(thread, deferred_lib); | 451 return CreateLibraryMirror(thread, deferred_lib); |
465 } | 452 } |
466 | 453 |
467 | |
468 DEFINE_NATIVE_ENTRY(LibraryMirror_libraryDependencies, 2) { | 454 DEFINE_NATIVE_ENTRY(LibraryMirror_libraryDependencies, 2) { |
469 GET_NON_NULL_NATIVE_ARGUMENT(Instance, lib_mirror, arguments->NativeArgAt(0)); | 455 GET_NON_NULL_NATIVE_ARGUMENT(Instance, lib_mirror, arguments->NativeArgAt(0)); |
470 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1)); | 456 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1)); |
471 const Library& lib = Library::Handle(ref.GetLibraryReferent()); | 457 const Library& lib = Library::Handle(ref.GetLibraryReferent()); |
472 | 458 |
473 Array& ports = Array::Handle(); | 459 Array& ports = Array::Handle(); |
474 Namespace& ns = Namespace::Handle(); | 460 Namespace& ns = Namespace::Handle(); |
475 Instance& dep = Instance::Handle(); | 461 Instance& dep = Instance::Handle(); |
476 LibraryPrefix& prefix = LibraryPrefix::Handle(); | 462 LibraryPrefix& prefix = LibraryPrefix::Handle(); |
477 GrowableObjectArray& deps = | 463 GrowableObjectArray& deps = |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
518 deps.Add(dep); | 504 deps.Add(dep); |
519 } | 505 } |
520 } | 506 } |
521 } | 507 } |
522 } | 508 } |
523 } | 509 } |
524 | 510 |
525 return deps.raw(); | 511 return deps.raw(); |
526 } | 512 } |
527 | 513 |
528 | |
529 static RawInstance* CreateTypeMirror(const AbstractType& type) { | 514 static RawInstance* CreateTypeMirror(const AbstractType& type) { |
530 if (type.IsTypeRef()) { | 515 if (type.IsTypeRef()) { |
531 AbstractType& ref_type = AbstractType::Handle(TypeRef::Cast(type).type()); | 516 AbstractType& ref_type = AbstractType::Handle(TypeRef::Cast(type).type()); |
532 ASSERT(!ref_type.IsTypeRef()); | 517 ASSERT(!ref_type.IsTypeRef()); |
533 ASSERT(ref_type.IsCanonical()); | 518 ASSERT(ref_type.IsCanonical()); |
534 return CreateTypeMirror(ref_type); | 519 return CreateTypeMirror(ref_type); |
535 } | 520 } |
536 ASSERT(type.IsFinalized()); | 521 ASSERT(type.IsFinalized()); |
537 PROPAGATE_IF_MALFORMED(type); | 522 PROPAGATE_IF_MALFORMED(type); |
538 ASSERT(type.IsCanonical() || type.IsTypeParameter() || type.IsBoundedType()); | 523 ASSERT(type.IsCanonical() || type.IsTypeParameter() || type.IsBoundedType()); |
(...skipping 25 matching lines...) Expand all Loading... |
564 Object::null_instance()); | 549 Object::null_instance()); |
565 } else if (type.IsBoundedType()) { | 550 } else if (type.IsBoundedType()) { |
566 AbstractType& actual_type = | 551 AbstractType& actual_type = |
567 AbstractType::Handle(BoundedType::Cast(type).type()); | 552 AbstractType::Handle(BoundedType::Cast(type).type()); |
568 return CreateTypeMirror(actual_type); | 553 return CreateTypeMirror(actual_type); |
569 } | 554 } |
570 UNREACHABLE(); | 555 UNREACHABLE(); |
571 return Instance::null(); | 556 return Instance::null(); |
572 } | 557 } |
573 | 558 |
574 | |
575 static RawInstance* CreateIsolateMirror() { | 559 static RawInstance* CreateIsolateMirror() { |
576 Thread* thread = Thread::Current(); | 560 Thread* thread = Thread::Current(); |
577 Isolate* isolate = thread->isolate(); | 561 Isolate* isolate = thread->isolate(); |
578 const String& debug_name = String::Handle(String::New(isolate->name())); | 562 const String& debug_name = String::Handle(String::New(isolate->name())); |
579 const Library& root_library = | 563 const Library& root_library = |
580 Library::Handle(thread->zone(), isolate->object_store()->root_library()); | 564 Library::Handle(thread->zone(), isolate->object_store()->root_library()); |
581 const Instance& root_library_mirror = | 565 const Instance& root_library_mirror = |
582 Instance::Handle(CreateLibraryMirror(thread, root_library)); | 566 Instance::Handle(CreateLibraryMirror(thread, root_library)); |
583 | 567 |
584 const Array& args = Array::Handle(Array::New(2)); | 568 const Array& args = Array::Handle(Array::New(2)); |
585 args.SetAt(0, debug_name); | 569 args.SetAt(0, debug_name); |
586 args.SetAt(1, root_library_mirror); | 570 args.SetAt(1, root_library_mirror); |
587 return CreateMirror(Symbols::_LocalIsolateMirror(), args); | 571 return CreateMirror(Symbols::_LocalIsolateMirror(), args); |
588 } | 572 } |
589 | 573 |
590 | |
591 static void VerifyMethodKindShifts() { | 574 static void VerifyMethodKindShifts() { |
592 #ifdef DEBUG | 575 #ifdef DEBUG |
593 Thread* thread = Thread::Current(); | 576 Thread* thread = Thread::Current(); |
594 Zone* zone = thread->zone(); | 577 Zone* zone = thread->zone(); |
595 const Library& lib = Library::Handle(zone, Library::MirrorsLibrary()); | 578 const Library& lib = Library::Handle(zone, Library::MirrorsLibrary()); |
596 const Class& cls = Class::Handle( | 579 const Class& cls = Class::Handle( |
597 zone, lib.LookupClassAllowPrivate(Symbols::_LocalMethodMirror())); | 580 zone, lib.LookupClassAllowPrivate(Symbols::_LocalMethodMirror())); |
598 const Error& error = Error::Handle(zone, cls.EnsureIsFinalized(thread)); | 581 const Error& error = Error::Handle(zone, cls.EnsureIsFinalized(thread)); |
599 ASSERT(error.IsNull()); | 582 ASSERT(error.IsNull()); |
600 | 583 |
601 Field& field = Field::Handle(); | 584 Field& field = Field::Handle(); |
602 Smi& value = Smi::Handle(); | 585 Smi& value = Smi::Handle(); |
603 | 586 |
604 #define CHECK_KIND_SHIFT(name) \ | 587 #define CHECK_KIND_SHIFT(name) \ |
605 field = cls.LookupField(String::Handle(String::New(#name))); \ | 588 field = cls.LookupField(String::Handle(String::New(#name))); \ |
606 ASSERT(!field.IsNull()); \ | 589 ASSERT(!field.IsNull()); \ |
607 value ^= field.StaticValue(); \ | 590 value ^= field.StaticValue(); \ |
608 ASSERT(value.Value() == Mirrors::name); | 591 ASSERT(value.Value() == Mirrors::name); |
609 MIRRORS_KIND_SHIFT_LIST(CHECK_KIND_SHIFT) | 592 MIRRORS_KIND_SHIFT_LIST(CHECK_KIND_SHIFT) |
610 #undef CHECK_KIND_SHIFT | 593 #undef CHECK_KIND_SHIFT |
611 #endif | 594 #endif |
612 } | 595 } |
613 | 596 |
614 | |
615 static RawInstance* ReturnResult(const Object& result) { | 597 static RawInstance* ReturnResult(const Object& result) { |
616 if (result.IsError()) { | 598 if (result.IsError()) { |
617 Exceptions::PropagateError(Error::Cast(result)); | 599 Exceptions::PropagateError(Error::Cast(result)); |
618 UNREACHABLE(); | 600 UNREACHABLE(); |
619 } | 601 } |
620 if (result.IsInstance()) { | 602 if (result.IsInstance()) { |
621 return Instance::Cast(result).raw(); | 603 return Instance::Cast(result).raw(); |
622 } | 604 } |
623 ASSERT(result.IsNull()); | 605 ASSERT(result.IsNull()); |
624 return Instance::null(); | 606 return Instance::null(); |
625 } | 607 } |
626 | 608 |
627 | |
628 // Invoke the function, or noSuchMethod if it is null. Propagate any unhandled | 609 // Invoke the function, or noSuchMethod if it is null. Propagate any unhandled |
629 // exceptions. Wrap and propagate any compilation errors. | 610 // exceptions. Wrap and propagate any compilation errors. |
630 static RawInstance* InvokeDynamicFunction(const Instance& receiver, | 611 static RawInstance* InvokeDynamicFunction(const Instance& receiver, |
631 const Function& function, | 612 const Function& function, |
632 const String& target_name, | 613 const String& target_name, |
633 const Array& args, | 614 const Array& args, |
634 const Array& args_descriptor_array) { | 615 const Array& args_descriptor_array) { |
635 // Note "args" is already the internal arguments with the receiver as the | 616 // Note "args" is already the internal arguments with the receiver as the |
636 // first element. | 617 // first element. |
637 Object& result = Object::Handle(); | 618 Object& result = Object::Handle(); |
638 ArgumentsDescriptor args_descriptor(args_descriptor_array); | 619 ArgumentsDescriptor args_descriptor(args_descriptor_array); |
639 if (function.IsNull() || !function.is_reflectable() || | 620 if (function.IsNull() || !function.is_reflectable() || |
640 !function.AreValidArguments(args_descriptor, NULL)) { | 621 !function.AreValidArguments(args_descriptor, NULL)) { |
641 result = DartEntry::InvokeNoSuchMethod(receiver, target_name, args, | 622 result = DartEntry::InvokeNoSuchMethod(receiver, target_name, args, |
642 args_descriptor_array); | 623 args_descriptor_array); |
643 } else { | 624 } else { |
644 result = DartEntry::InvokeFunction(function, args, args_descriptor_array); | 625 result = DartEntry::InvokeFunction(function, args, args_descriptor_array); |
645 } | 626 } |
646 return ReturnResult(result); | 627 return ReturnResult(result); |
647 } | 628 } |
648 | 629 |
649 | |
650 static RawInstance* InvokeLibraryGetter(const Library& library, | 630 static RawInstance* InvokeLibraryGetter(const Library& library, |
651 const String& getter_name, | 631 const String& getter_name, |
652 const bool throw_nsm_if_absent) { | 632 const bool throw_nsm_if_absent) { |
653 // To access a top-level we may need to use the Field or the getter Function. | 633 // To access a top-level we may need to use the Field or the getter Function. |
654 // The getter function may either be in the library or in the field's owner | 634 // The getter function may either be in the library or in the field's owner |
655 // class, depending on whether it was an actual getter, or an uninitialized | 635 // class, depending on whether it was an actual getter, or an uninitialized |
656 // field. | 636 // field. |
657 const Field& field = Field::Handle(library.LookupLocalField(getter_name)); | 637 const Field& field = Field::Handle(library.LookupLocalField(getter_name)); |
658 Function& getter = Function::Handle(); | 638 Function& getter = Function::Handle(); |
659 if (field.IsNull()) { | 639 if (field.IsNull()) { |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
695 InvocationMirror::kTopLevel, InvocationMirror::kGetter); | 675 InvocationMirror::kTopLevel, InvocationMirror::kGetter); |
696 UNREACHABLE(); | 676 UNREACHABLE(); |
697 } | 677 } |
698 | 678 |
699 // Fall through case: Indicate that we didn't find any function or field using | 679 // Fall through case: Indicate that we didn't find any function or field using |
700 // a special null instance. This is different from a field being null. Callers | 680 // a special null instance. This is different from a field being null. Callers |
701 // make sure that this null does not leak into Dartland. | 681 // make sure that this null does not leak into Dartland. |
702 return Object::sentinel().raw(); | 682 return Object::sentinel().raw(); |
703 } | 683 } |
704 | 684 |
705 | |
706 static RawInstance* InvokeClassGetter(const Class& klass, | 685 static RawInstance* InvokeClassGetter(const Class& klass, |
707 const String& getter_name, | 686 const String& getter_name, |
708 const bool throw_nsm_if_absent) { | 687 const bool throw_nsm_if_absent) { |
709 // Note static fields do not have implicit getters. | 688 // Note static fields do not have implicit getters. |
710 const Field& field = Field::Handle(klass.LookupStaticField(getter_name)); | 689 const Field& field = Field::Handle(klass.LookupStaticField(getter_name)); |
711 if (field.IsNull() || field.IsUninitialized()) { | 690 if (field.IsNull() || field.IsUninitialized()) { |
712 const String& internal_getter_name = | 691 const String& internal_getter_name = |
713 String::Handle(Field::GetterName(getter_name)); | 692 String::Handle(Field::GetterName(getter_name)); |
714 Function& getter = | 693 Function& getter = |
715 Function::Handle(klass.LookupStaticFunction(internal_getter_name)); | 694 Function::Handle(klass.LookupStaticFunction(internal_getter_name)); |
(...skipping 21 matching lines...) Expand all Loading... |
737 } | 716 } |
738 | 717 |
739 // Invoke the getter and return the result. | 718 // Invoke the getter and return the result. |
740 const Object& result = Object::Handle( | 719 const Object& result = Object::Handle( |
741 DartEntry::InvokeFunction(getter, Object::empty_array())); | 720 DartEntry::InvokeFunction(getter, Object::empty_array())); |
742 return ReturnResult(result); | 721 return ReturnResult(result); |
743 } | 722 } |
744 return field.StaticValue(); | 723 return field.StaticValue(); |
745 } | 724 } |
746 | 725 |
747 | |
748 static RawAbstractType* InstantiateType(const AbstractType& type, | 726 static RawAbstractType* InstantiateType(const AbstractType& type, |
749 const AbstractType& instantiator) { | 727 const AbstractType& instantiator) { |
750 ASSERT(type.IsFinalized()); | 728 ASSERT(type.IsFinalized()); |
751 PROPAGATE_IF_MALFORMED(type); | 729 PROPAGATE_IF_MALFORMED(type); |
752 ASSERT(type.IsCanonical() || type.IsTypeParameter() || type.IsBoundedType()); | 730 ASSERT(type.IsCanonical() || type.IsTypeParameter() || type.IsBoundedType()); |
753 | 731 |
754 // TODO(regis): Support uninstantiated type referring to function type params. | 732 // TODO(regis): Support uninstantiated type referring to function type params. |
755 if (!type.IsInstantiated(kFunctions)) { | 733 if (!type.IsInstantiated(kFunctions)) { |
756 UNIMPLEMENTED(); | 734 UNIMPLEMENTED(); |
757 } | 735 } |
(...skipping 14 matching lines...) Expand all Loading... |
772 instantiator_type_args, Object::null_type_arguments(), &bound_error, NULL, | 750 instantiator_type_args, Object::null_type_arguments(), &bound_error, NULL, |
773 NULL, Heap::kOld)); | 751 NULL, Heap::kOld)); |
774 if (!bound_error.IsNull()) { | 752 if (!bound_error.IsNull()) { |
775 Exceptions::PropagateError(bound_error); | 753 Exceptions::PropagateError(bound_error); |
776 UNREACHABLE(); | 754 UNREACHABLE(); |
777 } | 755 } |
778 ASSERT(result.IsFinalized()); | 756 ASSERT(result.IsFinalized()); |
779 return result.Canonicalize(); | 757 return result.Canonicalize(); |
780 } | 758 } |
781 | 759 |
782 | |
783 DEFINE_NATIVE_ENTRY(MirrorSystem_libraries, 0) { | 760 DEFINE_NATIVE_ENTRY(MirrorSystem_libraries, 0) { |
784 const GrowableObjectArray& libraries = | 761 const GrowableObjectArray& libraries = |
785 GrowableObjectArray::Handle(zone, isolate->object_store()->libraries()); | 762 GrowableObjectArray::Handle(zone, isolate->object_store()->libraries()); |
786 | 763 |
787 const intptr_t num_libraries = libraries.Length(); | 764 const intptr_t num_libraries = libraries.Length(); |
788 const GrowableObjectArray& library_mirrors = GrowableObjectArray::Handle( | 765 const GrowableObjectArray& library_mirrors = GrowableObjectArray::Handle( |
789 zone, GrowableObjectArray::New(num_libraries)); | 766 zone, GrowableObjectArray::New(num_libraries)); |
790 Library& library = Library::Handle(zone); | 767 Library& library = Library::Handle(zone); |
791 Instance& library_mirror = Instance::Handle(zone); | 768 Instance& library_mirror = Instance::Handle(zone); |
792 | 769 |
793 for (int i = 0; i < num_libraries; i++) { | 770 for (int i = 0; i < num_libraries; i++) { |
794 library ^= libraries.At(i); | 771 library ^= libraries.At(i); |
795 library_mirror = CreateLibraryMirror(thread, library); | 772 library_mirror = CreateLibraryMirror(thread, library); |
796 if (!library_mirror.IsNull() && library.Loaded()) { | 773 if (!library_mirror.IsNull() && library.Loaded()) { |
797 library_mirrors.Add(library_mirror); | 774 library_mirrors.Add(library_mirror); |
798 } | 775 } |
799 } | 776 } |
800 return library_mirrors.raw(); | 777 return library_mirrors.raw(); |
801 } | 778 } |
802 | 779 |
803 | |
804 DEFINE_NATIVE_ENTRY(MirrorSystem_isolate, 0) { | 780 DEFINE_NATIVE_ENTRY(MirrorSystem_isolate, 0) { |
805 VerifyMethodKindShifts(); | 781 VerifyMethodKindShifts(); |
806 | 782 |
807 return CreateIsolateMirror(); | 783 return CreateIsolateMirror(); |
808 } | 784 } |
809 | 785 |
810 | |
811 DEFINE_NATIVE_ENTRY(Mirrors_makeLocalClassMirror, 1) { | 786 DEFINE_NATIVE_ENTRY(Mirrors_makeLocalClassMirror, 1) { |
812 GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0)); | 787 GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0)); |
813 PROPAGATE_IF_MALFORMED(type); | 788 PROPAGATE_IF_MALFORMED(type); |
814 ASSERT(type.IsFinalized()); | 789 ASSERT(type.IsFinalized()); |
815 ASSERT(type.HasResolvedTypeClass()); | 790 ASSERT(type.HasResolvedTypeClass()); |
816 const Class& cls = Class::Handle(type.type_class()); | 791 const Class& cls = Class::Handle(type.type_class()); |
817 ASSERT(!cls.IsNull()); | 792 ASSERT(!cls.IsNull()); |
818 if (cls.IsDynamicClass() || cls.IsVoidClass() || cls.IsTypedefClass()) { | 793 if (cls.IsDynamicClass() || cls.IsVoidClass() || cls.IsTypedefClass()) { |
819 Exceptions::ThrowArgumentError(type); | 794 Exceptions::ThrowArgumentError(type); |
820 UNREACHABLE(); | 795 UNREACHABLE(); |
821 } | 796 } |
822 return CreateClassMirror(cls, AbstractType::Handle(cls.DeclarationType()), | 797 return CreateClassMirror(cls, AbstractType::Handle(cls.DeclarationType()), |
823 Bool::True(), // is_declaration | 798 Bool::True(), // is_declaration |
824 Object::null_instance()); | 799 Object::null_instance()); |
825 } | 800 } |
826 | 801 |
827 | |
828 DEFINE_NATIVE_ENTRY(Mirrors_makeLocalTypeMirror, 1) { | 802 DEFINE_NATIVE_ENTRY(Mirrors_makeLocalTypeMirror, 1) { |
829 GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0)); | 803 GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0)); |
830 return CreateTypeMirror(type); | 804 return CreateTypeMirror(type); |
831 } | 805 } |
832 | 806 |
833 | |
834 DEFINE_NATIVE_ENTRY(Mirrors_instantiateGenericType, 2) { | 807 DEFINE_NATIVE_ENTRY(Mirrors_instantiateGenericType, 2) { |
835 GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0)); | 808 GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0)); |
836 GET_NON_NULL_NATIVE_ARGUMENT(Array, args, arguments->NativeArgAt(1)); | 809 GET_NON_NULL_NATIVE_ARGUMENT(Array, args, arguments->NativeArgAt(1)); |
837 | 810 |
838 ASSERT(type.HasResolvedTypeClass()); | 811 ASSERT(type.HasResolvedTypeClass()); |
839 const Class& clz = Class::Handle(type.type_class()); | 812 const Class& clz = Class::Handle(type.type_class()); |
840 if (!clz.IsGeneric()) { | 813 if (!clz.IsGeneric()) { |
841 const Array& error_args = Array::Handle(Array::New(3)); | 814 const Array& error_args = Array::Handle(Array::New(3)); |
842 error_args.SetAt(0, type); | 815 error_args.SetAt(0, type); |
843 error_args.SetAt(1, String::Handle(String::New("key"))); | 816 error_args.SetAt(1, String::Handle(String::New("key"))); |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
886 error_args.SetAt(0, args); | 859 error_args.SetAt(0, args); |
887 error_args.SetAt(1, String::Handle(String::New("typeArguments"))); | 860 error_args.SetAt(1, String::Handle(String::New("typeArguments"))); |
888 error_args.SetAt(2, String::Handle(type_error.FormatMessage())); | 861 error_args.SetAt(2, String::Handle(type_error.FormatMessage())); |
889 Exceptions::ThrowByType(Exceptions::kArgumentValue, error_args); | 862 Exceptions::ThrowByType(Exceptions::kArgumentValue, error_args); |
890 UNREACHABLE(); | 863 UNREACHABLE(); |
891 } | 864 } |
892 | 865 |
893 return instantiated_type.raw(); | 866 return instantiated_type.raw(); |
894 } | 867 } |
895 | 868 |
896 | |
897 DEFINE_NATIVE_ENTRY(Mirrors_mangleName, 2) { | 869 DEFINE_NATIVE_ENTRY(Mirrors_mangleName, 2) { |
898 GET_NON_NULL_NATIVE_ARGUMENT(String, name, arguments->NativeArgAt(0)); | 870 GET_NON_NULL_NATIVE_ARGUMENT(String, name, arguments->NativeArgAt(0)); |
899 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1)); | 871 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1)); |
900 const Library& lib = Library::Handle(ref.GetLibraryReferent()); | 872 const Library& lib = Library::Handle(ref.GetLibraryReferent()); |
901 return lib.IsPrivate(name) ? lib.PrivateName(name) : name.raw(); | 873 return lib.IsPrivate(name) ? lib.PrivateName(name) : name.raw(); |
902 } | 874 } |
903 | 875 |
904 | |
905 DEFINE_NATIVE_ENTRY(MirrorReference_equals, 2) { | 876 DEFINE_NATIVE_ENTRY(MirrorReference_equals, 2) { |
906 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, a, arguments->NativeArgAt(0)); | 877 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, a, arguments->NativeArgAt(0)); |
907 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, b, arguments->NativeArgAt(1)); | 878 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, b, arguments->NativeArgAt(1)); |
908 return Bool::Get(a.referent() == b.referent()).raw(); | 879 return Bool::Get(a.referent() == b.referent()).raw(); |
909 } | 880 } |
910 | 881 |
911 | |
912 DEFINE_NATIVE_ENTRY(DeclarationMirror_metadata, 1) { | 882 DEFINE_NATIVE_ENTRY(DeclarationMirror_metadata, 1) { |
913 GET_NON_NULL_NATIVE_ARGUMENT(Instance, reflectee, arguments->NativeArgAt(0)); | 883 GET_NON_NULL_NATIVE_ARGUMENT(Instance, reflectee, arguments->NativeArgAt(0)); |
914 Object& decl = Object::Handle(); | 884 Object& decl = Object::Handle(); |
915 if (reflectee.IsMirrorReference()) { | 885 if (reflectee.IsMirrorReference()) { |
916 const MirrorReference& decl_ref = MirrorReference::Cast(reflectee); | 886 const MirrorReference& decl_ref = MirrorReference::Cast(reflectee); |
917 decl = decl_ref.referent(); | 887 decl = decl_ref.referent(); |
918 } else if (reflectee.IsTypeParameter()) { | 888 } else if (reflectee.IsTypeParameter()) { |
919 decl = reflectee.raw(); | 889 decl = reflectee.raw(); |
920 } else { | 890 } else { |
921 UNREACHABLE(); | 891 UNREACHABLE(); |
(...skipping 20 matching lines...) Expand all Loading... |
942 return Object::empty_array().raw(); | 912 return Object::empty_array().raw(); |
943 } | 913 } |
944 | 914 |
945 const Object& metadata = Object::Handle(library.GetMetadata(decl)); | 915 const Object& metadata = Object::Handle(library.GetMetadata(decl)); |
946 if (metadata.IsError()) { | 916 if (metadata.IsError()) { |
947 Exceptions::PropagateError(Error::Cast(metadata)); | 917 Exceptions::PropagateError(Error::Cast(metadata)); |
948 } | 918 } |
949 return metadata.raw(); | 919 return metadata.raw(); |
950 } | 920 } |
951 | 921 |
952 | |
953 DEFINE_NATIVE_ENTRY(FunctionTypeMirror_call_method, 2) { | 922 DEFINE_NATIVE_ENTRY(FunctionTypeMirror_call_method, 2) { |
954 GET_NON_NULL_NATIVE_ARGUMENT(Instance, owner_mirror, | 923 GET_NON_NULL_NATIVE_ARGUMENT(Instance, owner_mirror, |
955 arguments->NativeArgAt(0)); | 924 arguments->NativeArgAt(0)); |
956 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1)); | 925 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1)); |
957 // TODO(rmacnak): Return get:call() method on class _Closure instead? | 926 // TODO(rmacnak): Return get:call() method on class _Closure instead? |
958 // This now returns the result of invoking that call getter. | 927 // This now returns the result of invoking that call getter. |
959 const Function& func = Function::Handle(ref.GetFunctionReferent()); | 928 const Function& func = Function::Handle(ref.GetFunctionReferent()); |
960 ASSERT(!func.IsNull()); | 929 ASSERT(!func.IsNull()); |
961 return CreateMethodMirror(func, owner_mirror, AbstractType::Handle()); | 930 return CreateMethodMirror(func, owner_mirror, AbstractType::Handle()); |
962 } | 931 } |
963 | 932 |
964 | |
965 DEFINE_NATIVE_ENTRY(FunctionTypeMirror_parameters, 2) { | 933 DEFINE_NATIVE_ENTRY(FunctionTypeMirror_parameters, 2) { |
966 GET_NON_NULL_NATIVE_ARGUMENT(Instance, owner, arguments->NativeArgAt(0)); | 934 GET_NON_NULL_NATIVE_ARGUMENT(Instance, owner, arguments->NativeArgAt(0)); |
967 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1)); | 935 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1)); |
968 const Function& func = Function::Handle(ref.GetFunctionReferent()); | 936 const Function& func = Function::Handle(ref.GetFunctionReferent()); |
969 return CreateParameterMirrorList(func, owner); | 937 return CreateParameterMirrorList(func, owner); |
970 } | 938 } |
971 | 939 |
972 | |
973 DEFINE_NATIVE_ENTRY(FunctionTypeMirror_return_type, 1) { | 940 DEFINE_NATIVE_ENTRY(FunctionTypeMirror_return_type, 1) { |
974 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0)); | 941 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0)); |
975 const Function& func = Function::Handle(ref.GetFunctionReferent()); | 942 const Function& func = Function::Handle(ref.GetFunctionReferent()); |
976 ASSERT(!func.IsNull()); | 943 ASSERT(!func.IsNull()); |
977 AbstractType& type = AbstractType::Handle(func.result_type()); | 944 AbstractType& type = AbstractType::Handle(func.result_type()); |
978 // Signatures of function types are instantiated, but not canonical. | 945 // Signatures of function types are instantiated, but not canonical. |
979 return type.Canonicalize(); | 946 return type.Canonicalize(); |
980 } | 947 } |
981 | 948 |
982 | |
983 DEFINE_NATIVE_ENTRY(ClassMirror_libraryUri, 1) { | 949 DEFINE_NATIVE_ENTRY(ClassMirror_libraryUri, 1) { |
984 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0)); | 950 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0)); |
985 const Class& klass = Class::Handle(ref.GetClassReferent()); | 951 const Class& klass = Class::Handle(ref.GetClassReferent()); |
986 const Library& library = Library::Handle(klass.library()); | 952 const Library& library = Library::Handle(klass.library()); |
987 ASSERT(!library.IsNull()); | 953 ASSERT(!library.IsNull()); |
988 return library.url(); | 954 return library.url(); |
989 } | 955 } |
990 | 956 |
991 | |
992 DEFINE_NATIVE_ENTRY(ClassMirror_supertype, 1) { | 957 DEFINE_NATIVE_ENTRY(ClassMirror_supertype, 1) { |
993 GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0)); | 958 GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0)); |
994 PROPAGATE_IF_MALFORMED(type); | 959 PROPAGATE_IF_MALFORMED(type); |
995 ASSERT(type.IsFinalized()); | 960 ASSERT(type.IsFinalized()); |
996 const Class& cls = Class::Handle(type.type_class()); | 961 const Class& cls = Class::Handle(type.type_class()); |
997 const AbstractType& super_type = AbstractType::Handle(cls.super_type()); | 962 const AbstractType& super_type = AbstractType::Handle(cls.super_type()); |
998 ASSERT(super_type.IsNull() || super_type.IsFinalized()); | 963 ASSERT(super_type.IsNull() || super_type.IsFinalized()); |
999 return super_type.raw(); | 964 return super_type.raw(); |
1000 } | 965 } |
1001 | 966 |
1002 | |
1003 DEFINE_NATIVE_ENTRY(ClassMirror_supertype_instantiated, 1) { | 967 DEFINE_NATIVE_ENTRY(ClassMirror_supertype_instantiated, 1) { |
1004 GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0)); | 968 GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0)); |
1005 PROPAGATE_IF_MALFORMED(type); | 969 PROPAGATE_IF_MALFORMED(type); |
1006 ASSERT(type.IsFinalized()); | 970 ASSERT(type.IsFinalized()); |
1007 const Class& cls = Class::Handle(type.type_class()); | 971 const Class& cls = Class::Handle(type.type_class()); |
1008 const AbstractType& super_type = AbstractType::Handle(cls.super_type()); | 972 const AbstractType& super_type = AbstractType::Handle(cls.super_type()); |
1009 return InstantiateType(super_type, type); | 973 return InstantiateType(super_type, type); |
1010 } | 974 } |
1011 | 975 |
1012 | |
1013 DEFINE_NATIVE_ENTRY(ClassMirror_interfaces, 1) { | 976 DEFINE_NATIVE_ENTRY(ClassMirror_interfaces, 1) { |
1014 GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0)); | 977 GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0)); |
1015 PROPAGATE_IF_MALFORMED(type); | 978 PROPAGATE_IF_MALFORMED(type); |
1016 ASSERT(type.IsFinalized()); | 979 ASSERT(type.IsFinalized()); |
1017 const Class& cls = Class::Handle(type.type_class()); | 980 const Class& cls = Class::Handle(type.type_class()); |
1018 const Error& error = Error::Handle(cls.EnsureIsFinalized(thread)); | 981 const Error& error = Error::Handle(cls.EnsureIsFinalized(thread)); |
1019 if (!error.IsNull()) { | 982 if (!error.IsNull()) { |
1020 Exceptions::PropagateError(error); | 983 Exceptions::PropagateError(error); |
1021 } | 984 } |
1022 | 985 |
(...skipping 16 matching lines...) Expand all Loading... |
1039 | 1002 |
1040 for (int i = 0; i < interfaces.Length(); i++) { | 1003 for (int i = 0; i < interfaces.Length(); i++) { |
1041 interface ^= interfaces.At(i); | 1004 interface ^= interfaces.At(i); |
1042 interface = InstantiateType(interface, type); | 1005 interface = InstantiateType(interface, type); |
1043 interfaces_inst.SetAt(i, interface); | 1006 interfaces_inst.SetAt(i, interface); |
1044 } | 1007 } |
1045 | 1008 |
1046 return interfaces_inst.raw(); | 1009 return interfaces_inst.raw(); |
1047 } | 1010 } |
1048 | 1011 |
1049 | |
1050 DEFINE_NATIVE_ENTRY(ClassMirror_mixin, 1) { | 1012 DEFINE_NATIVE_ENTRY(ClassMirror_mixin, 1) { |
1051 GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0)); | 1013 GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0)); |
1052 PROPAGATE_IF_MALFORMED(type); | 1014 PROPAGATE_IF_MALFORMED(type); |
1053 ASSERT(type.IsFinalized()); | 1015 ASSERT(type.IsFinalized()); |
1054 const Class& cls = Class::Handle(type.type_class()); | 1016 const Class& cls = Class::Handle(type.type_class()); |
1055 const AbstractType& mixin_type = AbstractType::Handle(cls.mixin()); | 1017 const AbstractType& mixin_type = AbstractType::Handle(cls.mixin()); |
1056 ASSERT(mixin_type.IsNull() || mixin_type.IsFinalized()); | 1018 ASSERT(mixin_type.IsNull() || mixin_type.IsFinalized()); |
1057 return mixin_type.raw(); | 1019 return mixin_type.raw(); |
1058 } | 1020 } |
1059 | 1021 |
1060 | |
1061 DEFINE_NATIVE_ENTRY(ClassMirror_mixin_instantiated, 2) { | 1022 DEFINE_NATIVE_ENTRY(ClassMirror_mixin_instantiated, 2) { |
1062 GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0)); | 1023 GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0)); |
1063 GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, instantiator, | 1024 GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, instantiator, |
1064 arguments->NativeArgAt(1)); | 1025 arguments->NativeArgAt(1)); |
1065 PROPAGATE_IF_MALFORMED(type); | 1026 PROPAGATE_IF_MALFORMED(type); |
1066 ASSERT(type.IsFinalized()); | 1027 ASSERT(type.IsFinalized()); |
1067 const Class& cls = Class::Handle(type.type_class()); | 1028 const Class& cls = Class::Handle(type.type_class()); |
1068 const AbstractType& mixin_type = AbstractType::Handle(cls.mixin()); | 1029 const AbstractType& mixin_type = AbstractType::Handle(cls.mixin()); |
1069 if (mixin_type.IsNull()) { | 1030 if (mixin_type.IsNull()) { |
1070 return mixin_type.raw(); | 1031 return mixin_type.raw(); |
1071 } | 1032 } |
1072 | 1033 |
1073 return InstantiateType(mixin_type, instantiator); | 1034 return InstantiateType(mixin_type, instantiator); |
1074 } | 1035 } |
1075 | 1036 |
1076 | |
1077 DEFINE_NATIVE_ENTRY(ClassMirror_members, 3) { | 1037 DEFINE_NATIVE_ENTRY(ClassMirror_members, 3) { |
1078 GET_NON_NULL_NATIVE_ARGUMENT(Instance, owner_mirror, | 1038 GET_NON_NULL_NATIVE_ARGUMENT(Instance, owner_mirror, |
1079 arguments->NativeArgAt(0)); | 1039 arguments->NativeArgAt(0)); |
1080 GET_NATIVE_ARGUMENT(AbstractType, owner_instantiator, | 1040 GET_NATIVE_ARGUMENT(AbstractType, owner_instantiator, |
1081 arguments->NativeArgAt(1)); | 1041 arguments->NativeArgAt(1)); |
1082 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(2)); | 1042 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(2)); |
1083 const Class& klass = Class::Handle(ref.GetClassReferent()); | 1043 const Class& klass = Class::Handle(ref.GetClassReferent()); |
1084 | 1044 |
1085 const Error& error = Error::Handle(klass.EnsureIsFinalized(thread)); | 1045 const Error& error = Error::Handle(klass.EnsureIsFinalized(thread)); |
1086 if (!error.IsNull()) { | 1046 if (!error.IsNull()) { |
(...skipping 28 matching lines...) Expand all Loading... |
1115 func.kind() == RawFunction::kSetterFunction)) { | 1075 func.kind() == RawFunction::kSetterFunction)) { |
1116 member_mirror = | 1076 member_mirror = |
1117 CreateMethodMirror(func, owner_mirror, owner_instantiator); | 1077 CreateMethodMirror(func, owner_mirror, owner_instantiator); |
1118 member_mirrors.Add(member_mirror); | 1078 member_mirrors.Add(member_mirror); |
1119 } | 1079 } |
1120 } | 1080 } |
1121 | 1081 |
1122 return member_mirrors.raw(); | 1082 return member_mirrors.raw(); |
1123 } | 1083 } |
1124 | 1084 |
1125 | |
1126 DEFINE_NATIVE_ENTRY(ClassMirror_constructors, 3) { | 1085 DEFINE_NATIVE_ENTRY(ClassMirror_constructors, 3) { |
1127 GET_NON_NULL_NATIVE_ARGUMENT(Instance, owner_mirror, | 1086 GET_NON_NULL_NATIVE_ARGUMENT(Instance, owner_mirror, |
1128 arguments->NativeArgAt(0)); | 1087 arguments->NativeArgAt(0)); |
1129 GET_NATIVE_ARGUMENT(AbstractType, owner_instantiator, | 1088 GET_NATIVE_ARGUMENT(AbstractType, owner_instantiator, |
1130 arguments->NativeArgAt(1)); | 1089 arguments->NativeArgAt(1)); |
1131 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(2)); | 1090 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(2)); |
1132 const Class& klass = Class::Handle(ref.GetClassReferent()); | 1091 const Class& klass = Class::Handle(ref.GetClassReferent()); |
1133 | 1092 |
1134 const Error& error = Error::Handle(klass.EnsureIsFinalized(thread)); | 1093 const Error& error = Error::Handle(klass.EnsureIsFinalized(thread)); |
1135 if (!error.IsNull()) { | 1094 if (!error.IsNull()) { |
(...skipping 13 matching lines...) Expand all Loading... |
1149 if (func.is_reflectable() && func.kind() == RawFunction::kConstructor) { | 1108 if (func.is_reflectable() && func.kind() == RawFunction::kConstructor) { |
1150 constructor_mirror = | 1109 constructor_mirror = |
1151 CreateMethodMirror(func, owner_mirror, owner_instantiator); | 1110 CreateMethodMirror(func, owner_mirror, owner_instantiator); |
1152 constructor_mirrors.Add(constructor_mirror); | 1111 constructor_mirrors.Add(constructor_mirror); |
1153 } | 1112 } |
1154 } | 1113 } |
1155 | 1114 |
1156 return constructor_mirrors.raw(); | 1115 return constructor_mirrors.raw(); |
1157 } | 1116 } |
1158 | 1117 |
1159 | |
1160 DEFINE_NATIVE_ENTRY(LibraryMirror_members, 2) { | 1118 DEFINE_NATIVE_ENTRY(LibraryMirror_members, 2) { |
1161 GET_NON_NULL_NATIVE_ARGUMENT(Instance, owner_mirror, | 1119 GET_NON_NULL_NATIVE_ARGUMENT(Instance, owner_mirror, |
1162 arguments->NativeArgAt(0)); | 1120 arguments->NativeArgAt(0)); |
1163 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1)); | 1121 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1)); |
1164 const Library& library = Library::Handle(ref.GetLibraryReferent()); | 1122 const Library& library = Library::Handle(ref.GetLibraryReferent()); |
1165 | 1123 |
1166 Instance& member_mirror = Instance::Handle(); | 1124 Instance& member_mirror = Instance::Handle(); |
1167 const GrowableObjectArray& member_mirrors = | 1125 const GrowableObjectArray& member_mirrors = |
1168 GrowableObjectArray::Handle(GrowableObjectArray::New()); | 1126 GrowableObjectArray::Handle(GrowableObjectArray::New()); |
1169 | 1127 |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1202 member_mirror = | 1160 member_mirror = |
1203 CreateMethodMirror(func, owner_mirror, AbstractType::Handle()); | 1161 CreateMethodMirror(func, owner_mirror, AbstractType::Handle()); |
1204 member_mirrors.Add(member_mirror); | 1162 member_mirrors.Add(member_mirror); |
1205 } | 1163 } |
1206 } | 1164 } |
1207 } | 1165 } |
1208 | 1166 |
1209 return member_mirrors.raw(); | 1167 return member_mirrors.raw(); |
1210 } | 1168 } |
1211 | 1169 |
1212 | |
1213 DEFINE_NATIVE_ENTRY(ClassMirror_type_variables, 1) { | 1170 DEFINE_NATIVE_ENTRY(ClassMirror_type_variables, 1) { |
1214 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0)); | 1171 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0)); |
1215 const Class& klass = Class::Handle(ref.GetClassReferent()); | 1172 const Class& klass = Class::Handle(ref.GetClassReferent()); |
1216 const Error& error = Error::Handle(zone, klass.EnsureIsFinalized(thread)); | 1173 const Error& error = Error::Handle(zone, klass.EnsureIsFinalized(thread)); |
1217 if (!error.IsNull()) { | 1174 if (!error.IsNull()) { |
1218 Exceptions::PropagateError(error); | 1175 Exceptions::PropagateError(error); |
1219 UNREACHABLE(); | 1176 UNREACHABLE(); |
1220 } | 1177 } |
1221 return CreateTypeVariableList(klass); | 1178 return CreateTypeVariableList(klass); |
1222 } | 1179 } |
1223 | 1180 |
1224 | |
1225 DEFINE_NATIVE_ENTRY(ClassMirror_type_arguments, 1) { | 1181 DEFINE_NATIVE_ENTRY(ClassMirror_type_arguments, 1) { |
1226 GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0)); | 1182 GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0)); |
1227 | 1183 |
1228 const Class& cls = Class::Handle(type.type_class()); | 1184 const Class& cls = Class::Handle(type.type_class()); |
1229 const intptr_t num_params = cls.NumTypeParameters(); | 1185 const intptr_t num_params = cls.NumTypeParameters(); |
1230 | 1186 |
1231 if (num_params == 0) { | 1187 if (num_params == 0) { |
1232 return Object::empty_array().raw(); | 1188 return Object::empty_array().raw(); |
1233 } | 1189 } |
1234 | 1190 |
(...skipping 17 matching lines...) Expand all Loading... |
1252 ASSERT(args.Length() >= num_params); | 1208 ASSERT(args.Length() >= num_params); |
1253 const intptr_t num_inherited_args = args.Length() - num_params; | 1209 const intptr_t num_inherited_args = args.Length() - num_params; |
1254 for (intptr_t i = 0; i < num_params; i++) { | 1210 for (intptr_t i = 0; i < num_params; i++) { |
1255 arg_type ^= args.TypeAt(i + num_inherited_args); | 1211 arg_type ^= args.TypeAt(i + num_inherited_args); |
1256 type_mirror = CreateTypeMirror(arg_type); | 1212 type_mirror = CreateTypeMirror(arg_type); |
1257 result.SetAt(i, type_mirror); | 1213 result.SetAt(i, type_mirror); |
1258 } | 1214 } |
1259 return result.raw(); | 1215 return result.raw(); |
1260 } | 1216 } |
1261 | 1217 |
1262 | |
1263 DEFINE_NATIVE_ENTRY(TypeVariableMirror_owner, 1) { | 1218 DEFINE_NATIVE_ENTRY(TypeVariableMirror_owner, 1) { |
1264 GET_NON_NULL_NATIVE_ARGUMENT(TypeParameter, param, arguments->NativeArgAt(0)); | 1219 GET_NON_NULL_NATIVE_ARGUMENT(TypeParameter, param, arguments->NativeArgAt(0)); |
1265 const Class& owner = Class::Handle(param.parameterized_class()); | 1220 const Class& owner = Class::Handle(param.parameterized_class()); |
1266 const AbstractType& type = AbstractType::Handle(owner.DeclarationType()); | 1221 const AbstractType& type = AbstractType::Handle(owner.DeclarationType()); |
1267 return CreateClassMirror(owner, type, | 1222 return CreateClassMirror(owner, type, |
1268 Bool::True(), // is_declaration | 1223 Bool::True(), // is_declaration |
1269 Instance::null_instance()); | 1224 Instance::null_instance()); |
1270 } | 1225 } |
1271 | 1226 |
1272 | |
1273 DEFINE_NATIVE_ENTRY(TypeVariableMirror_upper_bound, 1) { | 1227 DEFINE_NATIVE_ENTRY(TypeVariableMirror_upper_bound, 1) { |
1274 GET_NON_NULL_NATIVE_ARGUMENT(TypeParameter, param, arguments->NativeArgAt(0)); | 1228 GET_NON_NULL_NATIVE_ARGUMENT(TypeParameter, param, arguments->NativeArgAt(0)); |
1275 return param.bound(); | 1229 return param.bound(); |
1276 } | 1230 } |
1277 | 1231 |
1278 | |
1279 DEFINE_NATIVE_ENTRY(Mirrors_evalInLibraryWithPrivateKey, 2) { | 1232 DEFINE_NATIVE_ENTRY(Mirrors_evalInLibraryWithPrivateKey, 2) { |
1280 GET_NON_NULL_NATIVE_ARGUMENT(String, expression, arguments->NativeArgAt(0)); | 1233 GET_NON_NULL_NATIVE_ARGUMENT(String, expression, arguments->NativeArgAt(0)); |
1281 GET_NATIVE_ARGUMENT(String, private_key, arguments->NativeArgAt(1)); | 1234 GET_NATIVE_ARGUMENT(String, private_key, arguments->NativeArgAt(1)); |
1282 | 1235 |
1283 const GrowableObjectArray& libraries = | 1236 const GrowableObjectArray& libraries = |
1284 GrowableObjectArray::Handle(isolate->object_store()->libraries()); | 1237 GrowableObjectArray::Handle(isolate->object_store()->libraries()); |
1285 const int num_libraries = libraries.Length(); | 1238 const int num_libraries = libraries.Length(); |
1286 Library& each_library = Library::Handle(); | 1239 Library& each_library = Library::Handle(); |
1287 Library& ctxt_library = Library::Handle(); | 1240 Library& ctxt_library = Library::Handle(); |
1288 String& library_key = String::Handle(); | 1241 String& library_key = String::Handle(); |
(...skipping 86 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1375 } | 1328 } |
1376 return call_result.raw(); | 1329 return call_result.raw(); |
1377 } | 1330 } |
1378 } | 1331 } |
1379 | 1332 |
1380 // Found an ordinary method. | 1333 // Found an ordinary method. |
1381 return InvokeDynamicFunction(reflectee, function, function_name, args, | 1334 return InvokeDynamicFunction(reflectee, function, function_name, args, |
1382 args_descriptor); | 1335 args_descriptor); |
1383 } | 1336 } |
1384 | 1337 |
1385 | |
1386 DEFINE_NATIVE_ENTRY(InstanceMirror_invokeGetter, 3) { | 1338 DEFINE_NATIVE_ENTRY(InstanceMirror_invokeGetter, 3) { |
1387 // Argument 0 is the mirror, which is unused by the native. It exists | 1339 // Argument 0 is the mirror, which is unused by the native. It exists |
1388 // because this native is an instance method in order to be polymorphic | 1340 // because this native is an instance method in order to be polymorphic |
1389 // with its cousins. | 1341 // with its cousins. |
1390 GET_NATIVE_ARGUMENT(Instance, reflectee, arguments->NativeArgAt(1)); | 1342 GET_NATIVE_ARGUMENT(Instance, reflectee, arguments->NativeArgAt(1)); |
1391 GET_NON_NULL_NATIVE_ARGUMENT(String, getter_name, arguments->NativeArgAt(2)); | 1343 GET_NON_NULL_NATIVE_ARGUMENT(String, getter_name, arguments->NativeArgAt(2)); |
1392 Class& klass = Class::Handle(reflectee.clazz()); | 1344 Class& klass = Class::Handle(reflectee.clazz()); |
1393 | 1345 |
1394 const String& internal_getter_name = | 1346 const String& internal_getter_name = |
1395 String::Handle(Field::GetterName(getter_name)); | 1347 String::Handle(Field::GetterName(getter_name)); |
(...skipping 15 matching lines...) Expand all Loading... |
1411 const Array& args = Array::Handle(zone, Array::New(kNumArgs)); | 1363 const Array& args = Array::Handle(zone, Array::New(kNumArgs)); |
1412 args.SetAt(0, reflectee); | 1364 args.SetAt(0, reflectee); |
1413 const Array& args_descriptor = Array::Handle( | 1365 const Array& args_descriptor = Array::Handle( |
1414 zone, ArgumentsDescriptor::New(kTypeArgsLen, args.Length())); | 1366 zone, ArgumentsDescriptor::New(kTypeArgsLen, args.Length())); |
1415 | 1367 |
1416 // InvokeDynamic invokes NoSuchMethod if the provided function is null. | 1368 // InvokeDynamic invokes NoSuchMethod if the provided function is null. |
1417 return InvokeDynamicFunction(reflectee, function, internal_getter_name, args, | 1369 return InvokeDynamicFunction(reflectee, function, internal_getter_name, args, |
1418 args_descriptor); | 1370 args_descriptor); |
1419 } | 1371 } |
1420 | 1372 |
1421 | |
1422 DEFINE_NATIVE_ENTRY(InstanceMirror_invokeSetter, 4) { | 1373 DEFINE_NATIVE_ENTRY(InstanceMirror_invokeSetter, 4) { |
1423 // Argument 0 is the mirror, which is unused by the native. It exists | 1374 // Argument 0 is the mirror, which is unused by the native. It exists |
1424 // because this native is an instance method in order to be polymorphic | 1375 // because this native is an instance method in order to be polymorphic |
1425 // with its cousins. | 1376 // with its cousins. |
1426 GET_NATIVE_ARGUMENT(Instance, reflectee, arguments->NativeArgAt(1)); | 1377 GET_NATIVE_ARGUMENT(Instance, reflectee, arguments->NativeArgAt(1)); |
1427 GET_NON_NULL_NATIVE_ARGUMENT(String, setter_name, arguments->NativeArgAt(2)); | 1378 GET_NON_NULL_NATIVE_ARGUMENT(String, setter_name, arguments->NativeArgAt(2)); |
1428 GET_NATIVE_ARGUMENT(Instance, value, arguments->NativeArgAt(3)); | 1379 GET_NATIVE_ARGUMENT(Instance, value, arguments->NativeArgAt(3)); |
1429 | 1380 |
1430 const Class& klass = Class::Handle(zone, reflectee.clazz()); | 1381 const Class& klass = Class::Handle(zone, reflectee.clazz()); |
1431 const String& internal_setter_name = | 1382 const String& internal_setter_name = |
1432 String::Handle(zone, Field::SetterName(setter_name)); | 1383 String::Handle(zone, Field::SetterName(setter_name)); |
1433 const Function& setter = Function::Handle( | 1384 const Function& setter = Function::Handle( |
1434 zone, Resolver::ResolveDynamicAnyArgs(zone, klass, internal_setter_name)); | 1385 zone, Resolver::ResolveDynamicAnyArgs(zone, klass, internal_setter_name)); |
1435 | 1386 |
1436 const int kTypeArgsLen = 0; | 1387 const int kTypeArgsLen = 0; |
1437 const int kNumArgs = 2; | 1388 const int kNumArgs = 2; |
1438 const Array& args = Array::Handle(zone, Array::New(kNumArgs)); | 1389 const Array& args = Array::Handle(zone, Array::New(kNumArgs)); |
1439 args.SetAt(0, reflectee); | 1390 args.SetAt(0, reflectee); |
1440 args.SetAt(1, value); | 1391 args.SetAt(1, value); |
1441 const Array& args_descriptor = Array::Handle( | 1392 const Array& args_descriptor = Array::Handle( |
1442 zone, ArgumentsDescriptor::New(kTypeArgsLen, args.Length())); | 1393 zone, ArgumentsDescriptor::New(kTypeArgsLen, args.Length())); |
1443 | 1394 |
1444 return InvokeDynamicFunction(reflectee, setter, internal_setter_name, args, | 1395 return InvokeDynamicFunction(reflectee, setter, internal_setter_name, args, |
1445 args_descriptor); | 1396 args_descriptor); |
1446 } | 1397 } |
1447 | 1398 |
1448 | |
1449 DEFINE_NATIVE_ENTRY(InstanceMirror_computeType, 1) { | 1399 DEFINE_NATIVE_ENTRY(InstanceMirror_computeType, 1) { |
1450 GET_NON_NULL_NATIVE_ARGUMENT(Instance, instance, arguments->NativeArgAt(0)); | 1400 GET_NON_NULL_NATIVE_ARGUMENT(Instance, instance, arguments->NativeArgAt(0)); |
1451 const AbstractType& type = AbstractType::Handle(instance.GetType(Heap::kNew)); | 1401 const AbstractType& type = AbstractType::Handle(instance.GetType(Heap::kNew)); |
1452 // The static type of null is specified to be the bottom type, however, the | 1402 // The static type of null is specified to be the bottom type, however, the |
1453 // runtime type of null is the Null type, which we correctly return here. | 1403 // runtime type of null is the Null type, which we correctly return here. |
1454 return type.Canonicalize(); | 1404 return type.Canonicalize(); |
1455 } | 1405 } |
1456 | 1406 |
1457 | |
1458 DEFINE_NATIVE_ENTRY(ClosureMirror_function, 1) { | 1407 DEFINE_NATIVE_ENTRY(ClosureMirror_function, 1) { |
1459 GET_NON_NULL_NATIVE_ARGUMENT(Instance, closure, arguments->NativeArgAt(0)); | 1408 GET_NON_NULL_NATIVE_ARGUMENT(Instance, closure, arguments->NativeArgAt(0)); |
1460 ASSERT(!closure.IsNull()); | 1409 ASSERT(!closure.IsNull()); |
1461 | 1410 |
1462 Function& function = Function::Handle(); | 1411 Function& function = Function::Handle(); |
1463 bool callable = closure.IsCallable(&function); | 1412 bool callable = closure.IsCallable(&function); |
1464 if (callable) { | 1413 if (callable) { |
1465 if (function.IsImplicitClosureFunction()) { | 1414 if (function.IsImplicitClosureFunction()) { |
1466 // The VM uses separate Functions for tear-offs, but the mirrors consider | 1415 // The VM uses separate Functions for tear-offs, but the mirrors consider |
1467 // the tear-offs to be the same as the torn-off methods. Avoid handing out | 1416 // the tear-offs to be the same as the torn-off methods. Avoid handing out |
(...skipping 14 matching lines...) Expand all Loading... |
1482 Class::Handle(Isolate::Current()->object_store()->object_class()); | 1431 Class::Handle(Isolate::Current()->object_store()->object_class()); |
1483 instantiator = Type::New(cls, arguments, TokenPosition::kNoSource); | 1432 instantiator = Type::New(cls, arguments, TokenPosition::kNoSource); |
1484 instantiator.SetIsFinalized(); | 1433 instantiator.SetIsFinalized(); |
1485 } | 1434 } |
1486 return CreateMethodMirror(function, Instance::null_instance(), | 1435 return CreateMethodMirror(function, Instance::null_instance(), |
1487 instantiator); | 1436 instantiator); |
1488 } | 1437 } |
1489 return Instance::null(); | 1438 return Instance::null(); |
1490 } | 1439 } |
1491 | 1440 |
1492 | |
1493 DEFINE_NATIVE_ENTRY(ClassMirror_invoke, 5) { | 1441 DEFINE_NATIVE_ENTRY(ClassMirror_invoke, 5) { |
1494 // Argument 0 is the mirror, which is unused by the native. It exists | 1442 // Argument 0 is the mirror, which is unused by the native. It exists |
1495 // because this native is an instance method in order to be polymorphic | 1443 // because this native is an instance method in order to be polymorphic |
1496 // with its cousins. | 1444 // with its cousins. |
1497 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1)); | 1445 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1)); |
1498 const Class& klass = Class::Handle(ref.GetClassReferent()); | 1446 const Class& klass = Class::Handle(ref.GetClassReferent()); |
1499 GET_NON_NULL_NATIVE_ARGUMENT(String, function_name, | 1447 GET_NON_NULL_NATIVE_ARGUMENT(String, function_name, |
1500 arguments->NativeArgAt(2)); | 1448 arguments->NativeArgAt(2)); |
1501 GET_NON_NULL_NATIVE_ARGUMENT(Array, args, arguments->NativeArgAt(3)); | 1449 GET_NON_NULL_NATIVE_ARGUMENT(Array, args, arguments->NativeArgAt(3)); |
1502 GET_NON_NULL_NATIVE_ARGUMENT(Array, arg_names, arguments->NativeArgAt(4)); | 1450 GET_NON_NULL_NATIVE_ARGUMENT(Array, arg_names, arguments->NativeArgAt(4)); |
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1563 | 1511 |
1564 Object& result = Object::Handle( | 1512 Object& result = Object::Handle( |
1565 DartEntry::InvokeFunction(function, args, args_descriptor_array)); | 1513 DartEntry::InvokeFunction(function, args, args_descriptor_array)); |
1566 if (result.IsError()) { | 1514 if (result.IsError()) { |
1567 Exceptions::PropagateError(Error::Cast(result)); | 1515 Exceptions::PropagateError(Error::Cast(result)); |
1568 UNREACHABLE(); | 1516 UNREACHABLE(); |
1569 } | 1517 } |
1570 return result.raw(); | 1518 return result.raw(); |
1571 } | 1519 } |
1572 | 1520 |
1573 | |
1574 DEFINE_NATIVE_ENTRY(ClassMirror_invokeGetter, 3) { | 1521 DEFINE_NATIVE_ENTRY(ClassMirror_invokeGetter, 3) { |
1575 // Argument 0 is the mirror, which is unused by the native. It exists | 1522 // Argument 0 is the mirror, which is unused by the native. It exists |
1576 // because this native is an instance method in order to be polymorphic | 1523 // because this native is an instance method in order to be polymorphic |
1577 // with its cousins. | 1524 // with its cousins. |
1578 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1)); | 1525 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1)); |
1579 const Class& klass = Class::Handle(ref.GetClassReferent()); | 1526 const Class& klass = Class::Handle(ref.GetClassReferent()); |
1580 const Error& error = Error::Handle(zone, klass.EnsureIsFinalized(thread)); | 1527 const Error& error = Error::Handle(zone, klass.EnsureIsFinalized(thread)); |
1581 if (!error.IsNull()) { | 1528 if (!error.IsNull()) { |
1582 Exceptions::PropagateError(error); | 1529 Exceptions::PropagateError(error); |
1583 UNREACHABLE(); | 1530 UNREACHABLE(); |
1584 } | 1531 } |
1585 GET_NON_NULL_NATIVE_ARGUMENT(String, getter_name, arguments->NativeArgAt(2)); | 1532 GET_NON_NULL_NATIVE_ARGUMENT(String, getter_name, arguments->NativeArgAt(2)); |
1586 return InvokeClassGetter(klass, getter_name, true); | 1533 return InvokeClassGetter(klass, getter_name, true); |
1587 } | 1534 } |
1588 | 1535 |
1589 | |
1590 DEFINE_NATIVE_ENTRY(ClassMirror_invokeSetter, 4) { | 1536 DEFINE_NATIVE_ENTRY(ClassMirror_invokeSetter, 4) { |
1591 // Argument 0 is the mirror, which is unused by the native. It exists | 1537 // Argument 0 is the mirror, which is unused by the native. It exists |
1592 // because this native is an instance method in order to be polymorphic | 1538 // because this native is an instance method in order to be polymorphic |
1593 // with its cousins. | 1539 // with its cousins. |
1594 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1)); | 1540 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1)); |
1595 const Class& klass = Class::Handle(ref.GetClassReferent()); | 1541 const Class& klass = Class::Handle(ref.GetClassReferent()); |
1596 GET_NON_NULL_NATIVE_ARGUMENT(String, setter_name, arguments->NativeArgAt(2)); | 1542 GET_NON_NULL_NATIVE_ARGUMENT(String, setter_name, arguments->NativeArgAt(2)); |
1597 GET_NATIVE_ARGUMENT(Instance, value, arguments->NativeArgAt(3)); | 1543 GET_NATIVE_ARGUMENT(Instance, value, arguments->NativeArgAt(3)); |
1598 | 1544 |
1599 const Error& error = Error::Handle(zone, klass.EnsureIsFinalized(thread)); | 1545 const Error& error = Error::Handle(zone, klass.EnsureIsFinalized(thread)); |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1640 ThrowNoSuchMethod(AbstractType::Handle(klass.RareType()), | 1586 ThrowNoSuchMethod(AbstractType::Handle(klass.RareType()), |
1641 internal_setter_name, setter, args, Object::null_array(), | 1587 internal_setter_name, setter, args, Object::null_array(), |
1642 InvocationMirror::kStatic, InvocationMirror::kSetter); | 1588 InvocationMirror::kStatic, InvocationMirror::kSetter); |
1643 UNREACHABLE(); | 1589 UNREACHABLE(); |
1644 } | 1590 } |
1645 | 1591 |
1646 field.SetStaticValue(value); | 1592 field.SetStaticValue(value); |
1647 return value.raw(); | 1593 return value.raw(); |
1648 } | 1594 } |
1649 | 1595 |
1650 | |
1651 DEFINE_NATIVE_ENTRY(ClassMirror_invokeConstructor, 5) { | 1596 DEFINE_NATIVE_ENTRY(ClassMirror_invokeConstructor, 5) { |
1652 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0)); | 1597 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0)); |
1653 const Class& klass = Class::Handle(ref.GetClassReferent()); | 1598 const Class& klass = Class::Handle(ref.GetClassReferent()); |
1654 GET_NATIVE_ARGUMENT(Type, type, arguments->NativeArgAt(1)); | 1599 GET_NATIVE_ARGUMENT(Type, type, arguments->NativeArgAt(1)); |
1655 GET_NON_NULL_NATIVE_ARGUMENT(String, constructor_name, | 1600 GET_NON_NULL_NATIVE_ARGUMENT(String, constructor_name, |
1656 arguments->NativeArgAt(2)); | 1601 arguments->NativeArgAt(2)); |
1657 GET_NON_NULL_NATIVE_ARGUMENT(Array, explicit_args, arguments->NativeArgAt(3)); | 1602 GET_NON_NULL_NATIVE_ARGUMENT(Array, explicit_args, arguments->NativeArgAt(3)); |
1658 GET_NON_NULL_NATIVE_ARGUMENT(Array, arg_names, arguments->NativeArgAt(4)); | 1603 GET_NON_NULL_NATIVE_ARGUMENT(Array, arg_names, arguments->NativeArgAt(4)); |
1659 | 1604 |
1660 const Error& error = Error::Handle(zone, klass.EnsureIsFinalized(thread)); | 1605 const Error& error = Error::Handle(zone, klass.EnsureIsFinalized(thread)); |
(...skipping 132 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1793 // Factories may return null. | 1738 // Factories may return null. |
1794 ASSERT(result.IsInstance() || result.IsNull()); | 1739 ASSERT(result.IsInstance() || result.IsNull()); |
1795 | 1740 |
1796 if (redirected_constructor.IsGenerativeConstructor()) { | 1741 if (redirected_constructor.IsGenerativeConstructor()) { |
1797 return new_object.raw(); | 1742 return new_object.raw(); |
1798 } else { | 1743 } else { |
1799 return result.raw(); | 1744 return result.raw(); |
1800 } | 1745 } |
1801 } | 1746 } |
1802 | 1747 |
1803 | |
1804 DEFINE_NATIVE_ENTRY(LibraryMirror_invoke, 5) { | 1748 DEFINE_NATIVE_ENTRY(LibraryMirror_invoke, 5) { |
1805 // Argument 0 is the mirror, which is unused by the native. It exists | 1749 // Argument 0 is the mirror, which is unused by the native. It exists |
1806 // because this native is an instance method in order to be polymorphic | 1750 // because this native is an instance method in order to be polymorphic |
1807 // with its cousins. | 1751 // with its cousins. |
1808 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1)); | 1752 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1)); |
1809 const Library& library = Library::Handle(ref.GetLibraryReferent()); | 1753 const Library& library = Library::Handle(ref.GetLibraryReferent()); |
1810 GET_NON_NULL_NATIVE_ARGUMENT(String, function_name, | 1754 GET_NON_NULL_NATIVE_ARGUMENT(String, function_name, |
1811 arguments->NativeArgAt(2)); | 1755 arguments->NativeArgAt(2)); |
1812 GET_NON_NULL_NATIVE_ARGUMENT(Array, args, arguments->NativeArgAt(3)); | 1756 GET_NON_NULL_NATIVE_ARGUMENT(Array, args, arguments->NativeArgAt(3)); |
1813 GET_NON_NULL_NATIVE_ARGUMENT(Array, arg_names, arguments->NativeArgAt(4)); | 1757 GET_NON_NULL_NATIVE_ARGUMENT(Array, arg_names, arguments->NativeArgAt(4)); |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1859 | 1803 |
1860 const Object& result = Object::Handle( | 1804 const Object& result = Object::Handle( |
1861 DartEntry::InvokeFunction(function, args, args_descriptor_array)); | 1805 DartEntry::InvokeFunction(function, args, args_descriptor_array)); |
1862 if (result.IsError()) { | 1806 if (result.IsError()) { |
1863 Exceptions::PropagateError(Error::Cast(result)); | 1807 Exceptions::PropagateError(Error::Cast(result)); |
1864 UNREACHABLE(); | 1808 UNREACHABLE(); |
1865 } | 1809 } |
1866 return result.raw(); | 1810 return result.raw(); |
1867 } | 1811 } |
1868 | 1812 |
1869 | |
1870 DEFINE_NATIVE_ENTRY(LibraryMirror_invokeGetter, 3) { | 1813 DEFINE_NATIVE_ENTRY(LibraryMirror_invokeGetter, 3) { |
1871 // Argument 0 is the mirror, which is unused by the native. It exists | 1814 // Argument 0 is the mirror, which is unused by the native. It exists |
1872 // because this native is an instance method in order to be polymorphic | 1815 // because this native is an instance method in order to be polymorphic |
1873 // with its cousins. | 1816 // with its cousins. |
1874 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1)); | 1817 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1)); |
1875 const Library& library = Library::Handle(ref.GetLibraryReferent()); | 1818 const Library& library = Library::Handle(ref.GetLibraryReferent()); |
1876 GET_NON_NULL_NATIVE_ARGUMENT(String, getter_name, arguments->NativeArgAt(2)); | 1819 GET_NON_NULL_NATIVE_ARGUMENT(String, getter_name, arguments->NativeArgAt(2)); |
1877 return InvokeLibraryGetter(library, getter_name, true); | 1820 return InvokeLibraryGetter(library, getter_name, true); |
1878 } | 1821 } |
1879 | 1822 |
1880 | |
1881 DEFINE_NATIVE_ENTRY(LibraryMirror_invokeSetter, 4) { | 1823 DEFINE_NATIVE_ENTRY(LibraryMirror_invokeSetter, 4) { |
1882 // Argument 0 is the mirror, which is unused by the native. It exists | 1824 // Argument 0 is the mirror, which is unused by the native. It exists |
1883 // because this native is an instance method in order to be polymorphic | 1825 // because this native is an instance method in order to be polymorphic |
1884 // with its cousins. | 1826 // with its cousins. |
1885 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1)); | 1827 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1)); |
1886 const Library& library = Library::Handle(ref.GetLibraryReferent()); | 1828 const Library& library = Library::Handle(ref.GetLibraryReferent()); |
1887 GET_NON_NULL_NATIVE_ARGUMENT(String, setter_name, arguments->NativeArgAt(2)); | 1829 GET_NON_NULL_NATIVE_ARGUMENT(String, setter_name, arguments->NativeArgAt(2)); |
1888 GET_NATIVE_ARGUMENT(Instance, value, arguments->NativeArgAt(3)); | 1830 GET_NATIVE_ARGUMENT(Instance, value, arguments->NativeArgAt(3)); |
1889 | 1831 |
1890 // To access a top-level we may need to use the Field or the | 1832 // To access a top-level we may need to use the Field or the |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1927 ThrowNoSuchMethod(Instance::null_instance(), internal_setter_name, setter, | 1869 ThrowNoSuchMethod(Instance::null_instance(), internal_setter_name, setter, |
1928 args, Object::null_array(), InvocationMirror::kTopLevel, | 1870 args, Object::null_array(), InvocationMirror::kTopLevel, |
1929 InvocationMirror::kSetter); | 1871 InvocationMirror::kSetter); |
1930 UNREACHABLE(); | 1872 UNREACHABLE(); |
1931 } | 1873 } |
1932 | 1874 |
1933 field.SetStaticValue(value); | 1875 field.SetStaticValue(value); |
1934 return value.raw(); | 1876 return value.raw(); |
1935 } | 1877 } |
1936 | 1878 |
1937 | |
1938 DEFINE_NATIVE_ENTRY(MethodMirror_owner, 2) { | 1879 DEFINE_NATIVE_ENTRY(MethodMirror_owner, 2) { |
1939 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0)); | 1880 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0)); |
1940 GET_NATIVE_ARGUMENT(AbstractType, instantiator, arguments->NativeArgAt(1)); | 1881 GET_NATIVE_ARGUMENT(AbstractType, instantiator, arguments->NativeArgAt(1)); |
1941 const Function& func = Function::Handle(ref.GetFunctionReferent()); | 1882 const Function& func = Function::Handle(ref.GetFunctionReferent()); |
1942 if (func.IsNonImplicitClosureFunction()) { | 1883 if (func.IsNonImplicitClosureFunction()) { |
1943 return CreateMethodMirror(Function::Handle(func.parent_function()), | 1884 return CreateMethodMirror(Function::Handle(func.parent_function()), |
1944 Object::null_instance(), instantiator); | 1885 Object::null_instance(), instantiator); |
1945 } | 1886 } |
1946 const Class& owner = Class::Handle(func.Owner()); | 1887 const Class& owner = Class::Handle(func.Owner()); |
1947 if (owner.IsTopLevel()) { | 1888 if (owner.IsTopLevel()) { |
1948 return CreateLibraryMirror(thread, Library::Handle(owner.library())); | 1889 return CreateLibraryMirror(thread, Library::Handle(owner.library())); |
1949 } | 1890 } |
1950 | 1891 |
1951 AbstractType& type = AbstractType::Handle(owner.DeclarationType()); | 1892 AbstractType& type = AbstractType::Handle(owner.DeclarationType()); |
1952 return CreateClassMirror(owner, type, Bool::True(), Object::null_instance()); | 1893 return CreateClassMirror(owner, type, Bool::True(), Object::null_instance()); |
1953 } | 1894 } |
1954 | 1895 |
1955 | |
1956 DEFINE_NATIVE_ENTRY(MethodMirror_parameters, 2) { | 1896 DEFINE_NATIVE_ENTRY(MethodMirror_parameters, 2) { |
1957 GET_NON_NULL_NATIVE_ARGUMENT(Instance, owner, arguments->NativeArgAt(0)); | 1897 GET_NON_NULL_NATIVE_ARGUMENT(Instance, owner, arguments->NativeArgAt(0)); |
1958 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1)); | 1898 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1)); |
1959 const Function& func = Function::Handle(ref.GetFunctionReferent()); | 1899 const Function& func = Function::Handle(ref.GetFunctionReferent()); |
1960 return CreateParameterMirrorList(func, owner); | 1900 return CreateParameterMirrorList(func, owner); |
1961 } | 1901 } |
1962 | 1902 |
1963 | |
1964 DEFINE_NATIVE_ENTRY(MethodMirror_return_type, 2) { | 1903 DEFINE_NATIVE_ENTRY(MethodMirror_return_type, 2) { |
1965 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0)); | 1904 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0)); |
1966 const Function& func = Function::Handle(ref.GetFunctionReferent()); | 1905 const Function& func = Function::Handle(ref.GetFunctionReferent()); |
1967 GET_NATIVE_ARGUMENT(AbstractType, instantiator, arguments->NativeArgAt(1)); | 1906 GET_NATIVE_ARGUMENT(AbstractType, instantiator, arguments->NativeArgAt(1)); |
1968 // We handle constructors in Dart code. | 1907 // We handle constructors in Dart code. |
1969 ASSERT(!func.IsGenerativeConstructor()); | 1908 ASSERT(!func.IsGenerativeConstructor()); |
1970 AbstractType& type = AbstractType::Handle(func.result_type()); | 1909 AbstractType& type = AbstractType::Handle(func.result_type()); |
1971 type ^= type.Canonicalize(); // Instantiated signatures are not canonical. | 1910 type ^= type.Canonicalize(); // Instantiated signatures are not canonical. |
1972 return InstantiateType(type, instantiator); | 1911 return InstantiateType(type, instantiator); |
1973 } | 1912 } |
1974 | 1913 |
1975 | |
1976 DEFINE_NATIVE_ENTRY(MethodMirror_source, 1) { | 1914 DEFINE_NATIVE_ENTRY(MethodMirror_source, 1) { |
1977 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0)); | 1915 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0)); |
1978 const Function& func = Function::Handle(ref.GetFunctionReferent()); | 1916 const Function& func = Function::Handle(ref.GetFunctionReferent()); |
1979 return func.GetSource(); | 1917 return func.GetSource(); |
1980 } | 1918 } |
1981 | 1919 |
1982 | |
1983 static RawInstance* CreateSourceLocation(const String& uri, | 1920 static RawInstance* CreateSourceLocation(const String& uri, |
1984 intptr_t line, | 1921 intptr_t line, |
1985 intptr_t column) { | 1922 intptr_t column) { |
1986 const Array& args = Array::Handle(Array::New(3)); | 1923 const Array& args = Array::Handle(Array::New(3)); |
1987 args.SetAt(0, uri); | 1924 args.SetAt(0, uri); |
1988 args.SetAt(1, Smi::Handle(Smi::New(line))); | 1925 args.SetAt(1, Smi::Handle(Smi::New(line))); |
1989 args.SetAt(2, Smi::Handle(Smi::New(column))); | 1926 args.SetAt(2, Smi::Handle(Smi::New(column))); |
1990 return CreateMirror(Symbols::_SourceLocation(), args); | 1927 return CreateMirror(Symbols::_SourceLocation(), args); |
1991 } | 1928 } |
1992 | 1929 |
1993 | |
1994 DEFINE_NATIVE_ENTRY(DeclarationMirror_location, 1) { | 1930 DEFINE_NATIVE_ENTRY(DeclarationMirror_location, 1) { |
1995 GET_NON_NULL_NATIVE_ARGUMENT(Instance, reflectee, arguments->NativeArgAt(0)); | 1931 GET_NON_NULL_NATIVE_ARGUMENT(Instance, reflectee, arguments->NativeArgAt(0)); |
1996 Object& decl = Object::Handle(zone); | 1932 Object& decl = Object::Handle(zone); |
1997 if (reflectee.IsMirrorReference()) { | 1933 if (reflectee.IsMirrorReference()) { |
1998 const MirrorReference& decl_ref = MirrorReference::Cast(reflectee); | 1934 const MirrorReference& decl_ref = MirrorReference::Cast(reflectee); |
1999 decl = decl_ref.referent(); | 1935 decl = decl_ref.referent(); |
2000 } else if (reflectee.IsTypeParameter()) { | 1936 } else if (reflectee.IsTypeParameter()) { |
2001 decl = reflectee.raw(); | 1937 decl = reflectee.raw(); |
2002 } else { | 1938 } else { |
2003 UNREACHABLE(); | 1939 UNREACHABLE(); |
(...skipping 62 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2066 } else { | 2002 } else { |
2067 // Avoid the slow path of printing the token stream when precise source | 2003 // Avoid the slow path of printing the token stream when precise source |
2068 // information is not available. | 2004 // information is not available. |
2069 script.GetTokenLocation(token_pos, &from_line, NULL); | 2005 script.GetTokenLocation(token_pos, &from_line, NULL); |
2070 } | 2006 } |
2071 // We should always have at least the line number. | 2007 // We should always have at least the line number. |
2072 ASSERT(from_line != 0); | 2008 ASSERT(from_line != 0); |
2073 return CreateSourceLocation(uri, from_line, from_col); | 2009 return CreateSourceLocation(uri, from_line, from_col); |
2074 } | 2010 } |
2075 | 2011 |
2076 | |
2077 DEFINE_NATIVE_ENTRY(TypedefMirror_referent, 1) { | 2012 DEFINE_NATIVE_ENTRY(TypedefMirror_referent, 1) { |
2078 GET_NON_NULL_NATIVE_ARGUMENT(Type, type, arguments->NativeArgAt(0)); | 2013 GET_NON_NULL_NATIVE_ARGUMENT(Type, type, arguments->NativeArgAt(0)); |
2079 ASSERT(type.IsFunctionType()); | 2014 ASSERT(type.IsFunctionType()); |
2080 const Class& cls = Class::Handle(type.type_class()); | 2015 const Class& cls = Class::Handle(type.type_class()); |
2081 ASSERT(cls.IsTypedefClass()); | 2016 ASSERT(cls.IsTypedefClass()); |
2082 const Function& sig_func = Function::Handle(cls.signature_function()); | 2017 const Function& sig_func = Function::Handle(cls.signature_function()); |
2083 Type& referent_type = Type::Handle(sig_func.SignatureType()); | 2018 Type& referent_type = Type::Handle(sig_func.SignatureType()); |
2084 ASSERT(cls.raw() == referent_type.type_class()); | 2019 ASSERT(cls.raw() == referent_type.type_class()); |
2085 referent_type ^= InstantiateType(referent_type, type); | 2020 referent_type ^= InstantiateType(referent_type, type); |
2086 return CreateFunctionTypeMirror(referent_type); | 2021 return CreateFunctionTypeMirror(referent_type); |
2087 } | 2022 } |
2088 | 2023 |
2089 | |
2090 DEFINE_NATIVE_ENTRY(ParameterMirror_type, 3) { | 2024 DEFINE_NATIVE_ENTRY(ParameterMirror_type, 3) { |
2091 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0)); | 2025 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0)); |
2092 GET_NON_NULL_NATIVE_ARGUMENT(Smi, pos, arguments->NativeArgAt(1)); | 2026 GET_NON_NULL_NATIVE_ARGUMENT(Smi, pos, arguments->NativeArgAt(1)); |
2093 GET_NATIVE_ARGUMENT(AbstractType, instantiator, arguments->NativeArgAt(2)); | 2027 GET_NATIVE_ARGUMENT(AbstractType, instantiator, arguments->NativeArgAt(2)); |
2094 const Function& func = Function::Handle(ref.GetFunctionReferent()); | 2028 const Function& func = Function::Handle(ref.GetFunctionReferent()); |
2095 AbstractType& type = AbstractType::Handle( | 2029 AbstractType& type = AbstractType::Handle( |
2096 func.ParameterTypeAt(func.NumImplicitParameters() + pos.Value())); | 2030 func.ParameterTypeAt(func.NumImplicitParameters() + pos.Value())); |
2097 type ^= type.Canonicalize(); // Instantiated signatures are not canonical. | 2031 type ^= type.Canonicalize(); // Instantiated signatures are not canonical. |
2098 return InstantiateType(type, instantiator); | 2032 return InstantiateType(type, instantiator); |
2099 } | 2033 } |
2100 | 2034 |
2101 | |
2102 DEFINE_NATIVE_ENTRY(VariableMirror_type, 2) { | 2035 DEFINE_NATIVE_ENTRY(VariableMirror_type, 2) { |
2103 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0)); | 2036 GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0)); |
2104 const Field& field = Field::Handle(ref.GetFieldReferent()); | 2037 const Field& field = Field::Handle(ref.GetFieldReferent()); |
2105 GET_NATIVE_ARGUMENT(AbstractType, instantiator, arguments->NativeArgAt(1)); | 2038 GET_NATIVE_ARGUMENT(AbstractType, instantiator, arguments->NativeArgAt(1)); |
2106 const AbstractType& type = AbstractType::Handle(field.type()); | 2039 const AbstractType& type = AbstractType::Handle(field.type()); |
2107 return InstantiateType(type, instantiator); | 2040 return InstantiateType(type, instantiator); |
2108 } | 2041 } |
2109 | 2042 |
2110 DEFINE_NATIVE_ENTRY(TypeMirror_subtypeTest, 2) { | 2043 DEFINE_NATIVE_ENTRY(TypeMirror_subtypeTest, 2) { |
2111 GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, a, arguments->NativeArgAt(0)); | 2044 GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, a, arguments->NativeArgAt(0)); |
2112 GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, b, arguments->NativeArgAt(1)); | 2045 GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, b, arguments->NativeArgAt(1)); |
2113 return Bool::Get(a.IsSubtypeOf(b, NULL, NULL, Heap::kNew)).raw(); | 2046 return Bool::Get(a.IsSubtypeOf(b, NULL, NULL, Heap::kNew)).raw(); |
2114 } | 2047 } |
2115 | 2048 |
2116 #endif // !PRODUCT && !DART_PRECOMPILED_RUNTIME | 2049 #endif // !PRODUCT && !DART_PRECOMPILED_RUNTIME |
2117 | 2050 |
2118 } // namespace dart | 2051 } // namespace dart |
OLD | NEW |