-
Notifications
You must be signed in to change notification settings - Fork 1.6k
/
mirrors.dart
1478 lines (1354 loc) · 48.9 KB
/
mirrors.dart
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
// Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
// For the purposes of the mirrors library, we adopt a naming
// convention with respect to getters and setters. Specifically, for
// some variable or field...
//
// var myField;
//
// ...the getter is named 'myField' and the setter is named
// 'myField='. This allows us to assign unique names to getters and
// setters for the purposes of member lookup.
/**
* Basic reflection in Dart,
* with support for introspection and dynamic invocation.
*
* *Introspection* is that subset of reflection by which a running
* program can examine its own structure. For example, a function
* that prints out the names of all the members of an arbitrary object.
*
* *Dynamic invocation* refers the ability to evaluate code that
* has not been literally specified at compile time, such as calling a method
* whose name is provided as an argument (because it is looked up
* in a database, or provided interactively by the user).
*
* ## How to interpret this library's documentation
*
* As a rule, the names of Dart declarations are represented using
* instances of class [Symbol]. Whenever the doc speaks of an object *s*
* of class [Symbol] denoting a name, it means the string that
* was used to construct *s*.
*
* The documentation frequently abuses notation with
* Dart pseudo-code such as [:o.x(a):], where
* o and a are defined to be objects; what is actually meant in these
* cases is [:o'.x(a'):] where *o'* and *a'* are Dart variables
* bound to *o* and *a* respectively. Furthermore, *o'* and *a'*
* are assumed to be fresh variables (meaning that they are
* distinct from any other variables in the program).
*
* Sometimes the documentation refers to *serializable* objects.
* An object is serializable across isolates if and only if it is an instance of
* num, bool, String, a list of objects that are serializable
* across isolates, or a map with keys and values that are all serializable across
* isolates.
*
* ## Status: Unstable
*
* The dart:mirrors library is unstable and its API might change slightly as a
* result of user feedback. This library is only supported by the Dart VM and
* only available on some platforms.
*
* {@category VM}
*/
library dart.mirrors;
import "dart:core";
import 'dart:async' show Future;
import "dart:_internal" show Since;
// TODO: Move AbstractClassInstantiationError here when removed from dart:core.
export "dart:core" show AbstractClassInstantiationError;
/**
* A [MirrorSystem] is the main interface used to reflect on a set of
* associated libraries.
*
* At runtime each running isolate has a distinct [MirrorSystem].
*
* It is also possible to have a [MirrorSystem] which represents a set
* of libraries which are not running -- perhaps at compile-time. In
* this case, all available reflective functionality would be
* supported, but runtime functionality (such as invoking a function
* or inspecting the contents of a variable) would fail dynamically.
*/
abstract class MirrorSystem {
/**
* All libraries known to the mirror system, indexed by their URI.
*
* Returns an unmodifiable map of the libraries with [LibraryMirror.uri] as
* keys.
*
* For a runtime mirror system, only libraries which are currently loaded
* are included, and repeated calls of this method may return different maps
* as libraries are loaded.
*/
Map<Uri, LibraryMirror> get libraries;
/**
* Returns the unique library named [libraryName] if it exists.
*
* If no unique library exists, an error is thrown.
*/
external LibraryMirror findLibrary(Symbol libraryName);
/**
* A mirror on the isolate associated with this [MirrorSystem].
*
* This may be null if this mirror system is not running.
*/
IsolateMirror get isolate;
/**
* A mirror on the [:dynamic:] type.
*/
TypeMirror get dynamicType;
/**
* A mirror on the [:void:] type.
*/
TypeMirror get voidType;
/**
* A mirror on the [:Never:] type.
*/
@Since("2.8")
TypeMirror get neverType;
/**
* Returns the name of [symbol].
*
* The following text is non-normative:
*
* Using this method may result in larger output. If possible, use
* [MirrorsUsed] to specify which symbols must be retained in clear text.
*/
external static String getName(Symbol symbol);
/**
* Returns a symbol for [name].
*
* If [library] is not a [LibraryMirror] or if [name] is a private identifier
* and [library] is `null`, throws an [ArgumentError]. If [name] is a private
* identifier, the symbol returned is with respect to [library].
*
* The following text is non-normative:
*
* Using this method may result in larger output. If possible, use
* the const constructor of [Symbol] or symbol literals.
*/
external static Symbol getSymbol(String name, [LibraryMirror? library]);
}
/**
* Returns a [MirrorSystem] for the current isolate.
*/
external MirrorSystem currentMirrorSystem();
/**
* Reflects an instance.
*
* Returns an [InstanceMirror] reflecting [reflectee]. If [reflectee] is a
* function or an instance of a class that has a [:call:] method, the returned
* instance mirror will be a [ClosureMirror].
*
* Note that since one cannot obtain an object from another isolate, this
* function can only be used to obtain mirrors on objects of the current
* isolate.
*/
external InstanceMirror reflect(dynamic reflectee);
/**
* Reflects a class declaration.
*
* Let *C* be the original class declaration of the class represented by [key].
* This function returns a [ClassMirror] reflecting *C*.
*
* If [key] is not an instance of [Type], then this function throws an
* [ArgumentError]. If [key] is the Type for dynamic or a function typedef,
* throws an [ArgumentError].
*
* Note that since one cannot obtain a [Type] object from another isolate, this
* function can only be used to obtain class mirrors on classes of the current
* isolate.
*/
external ClassMirror reflectClass(Type key);
/**
* Reflects the type represented by [key].
*
* If [key] is not an instance of [Type], then this function throws an
* [ArgumentError].
*
* Optionally takes a list of [typeArguments] for generic classes. If the list
* is provided, then the [key] must be a generic class type, and the number of
* the provided type arguments must be equal to the number of type variables
* declared by the class.
*
* Note that since one cannot obtain a [Type] object from another isolate, this
* function can only be used to obtain type mirrors on types of the current
* isolate.
*/
external TypeMirror reflectType(Type key, [List<Type>? typeArguments]);
/**
* A [Mirror] reflects some Dart language entity.
*
* Every [Mirror] originates from some [MirrorSystem].
*/
abstract class Mirror {}
/**
* An [IsolateMirror] reflects an isolate.
*/
abstract class IsolateMirror implements Mirror {
/**
* A unique name used to refer to the isolate in debugging messages.
*/
String get debugName;
/**
* Whether this mirror reflects the currently running isolate.
*/
bool get isCurrent;
/**
* The root library for the reflected isolate.
*/
LibraryMirror get rootLibrary;
/**
* Whether [other] is an [IsolateMirror] on the same isolate as this mirror.
*
* The equality holds if and only if
*
* 1. [other] is a mirror of the same kind, and
* 2. the isolate being reflected by this mirror is the same isolate being
* reflected by [other].
*/
bool operator ==(Object other);
/**
* Loads the library at the given uri into this isolate.
*
* WARNING: You are strongly encouraged to use Isolate.spawnUri instead when
* possible. IsolateMirror.loadUri should only be used when synchronous
* communication or shared state with dynamically loaded code is needed.
*
* If a library with the same canonicalized uri has already been loaded,
* the existing library will be returned. (The isolate will not load a new
* copy of the library.)
*
* This behavior is similar to the behavior of an import statement that
* appears in the root library, except that the import scope of the root
* library is not changed.
*/
Future<LibraryMirror> loadUri(Uri uri);
}
/**
* A [DeclarationMirror] reflects some entity declared in a Dart program.
*/
abstract class DeclarationMirror implements Mirror {
/**
* The simple name for this Dart language entity.
*
* The simple name is in most cases the identifier name of the entity,
* such as 'myMethod' for a method, [:void myMethod() {...}:] or 'mylibrary'
* for a [:library 'mylibrary';:] declaration.
*/
Symbol get simpleName;
/**
* The fully-qualified name for this Dart language entity.
*
* This name is qualified by the name of the owner. For instance,
* the qualified name of a method 'method' in class 'Class' in
* library 'library' is 'library.Class.method'.
*
* Returns a [Symbol] constructed from a string representing the
* fully qualified name of the reflectee.
* Let *o* be the [owner] of this mirror, let *r* be the reflectee of
* this mirror, let *p* be the fully qualified
* name of the reflectee of *o*, and let *s* be the simple name of *r*
* computed by [simpleName].
* The fully qualified name of *r* is the
* concatenation of *p*, '.', and *s*.
*
* Because an isolate can contain more than one library with the same name (at
* different URIs), a fully-qualified name does not uniquely identify any
* language entity.
*/
Symbol get qualifiedName;
/**
* A mirror on the owner of this Dart language entity.
*
* The owner is the declaration immediately surrounding the reflectee:
*
* * For a library, the owner is [:null:].
* * For a class declaration, typedef or top level function or variable, the
* owner is the enclosing library.
* * For a mixin application `S with M`, the owner is the owner of `M`.
* * For a constructor, the owner is the immediately enclosing class.
* * For a method, instance variable or a static variable, the owner is the
* immediately enclosing class, unless the class is a mixin application
* `S with M`, in which case the owner is `M`. Note that `M` may be an
* invocation of a generic.
* * For a parameter, local variable or local function the owner is the
* immediately enclosing function.
*/
DeclarationMirror? get owner;
/**
* Whether this declaration is library private.
*
* Always returns `false` for a library declaration,
* otherwise returns `true` if the declaration's name starts with an
* underscore character (`_`), and `false` if it doesn't.
*/
bool get isPrivate;
/**
* Whether this declaration is top-level.
*
* A declaration is considered top-level if its [owner] is a [LibraryMirror].
*/
bool get isTopLevel;
/**
* The source location of this Dart language entity, or [:null:] if the
* entity is synthetic.
*
* If the reflectee is a variable, the returned location gives the position
* of the variable name at its point of declaration.
*
* If the reflectee is a library, class, typedef, function or type variable
* with associated metadata, the returned location gives the position of the
* first metadata declaration associated with the reflectee.
*
* Otherwise:
*
* If the reflectee is a library, the returned location gives the position of
* the keyword 'library' at the reflectee's point of declaration, if the
* reflectee is a named library, or the first character of the first line in
* the compilation unit defining the reflectee if the reflectee is anonymous.
*
* If the reflectee is an abstract class, the returned location gives the
* position of the keyword 'abstract' at the reflectee's point of declaration.
* Otherwise, if the reflectee is a class, the returned location gives the
* position of the keyword 'class' at the reflectee's point of declaration.
*
* If the reflectee is a typedef the returned location gives the position of
* the of the keyword 'typedef' at the reflectee's point of declaration.
*
* If the reflectee is a function with a declared return type, the returned
* location gives the position of the function's return type at the
* reflectee's point of declaration. Otherwise. the returned location gives
* the position of the function's name at the reflectee's point of
* declaration.
*
* This operation is optional and may throw an [UnsupportedError].
*/
SourceLocation? get location;
/**
* A list of the metadata associated with this declaration.
*
* Let *D* be the declaration this mirror reflects.
* If *D* is decorated with annotations *A1, ..., An*
* where *n > 0*, then for each annotation *Ai* associated
* with *D, 1 <= i <= n*, let *ci* be the constant object
* specified by *Ai*. Then this method returns a list whose
* members are instance mirrors on *c1, ..., cn*.
* If no annotations are associated with *D*, then
* an empty list is returned.
*
* If evaluating any of *c1, ..., cn* would cause a
* compilation error
* the effect is the same as if a non-reflective compilation error
* had been encountered.
*/
List<InstanceMirror> get metadata;
}
/**
* An [ObjectMirror] is a common superinterface of [InstanceMirror],
* [ClassMirror], and [LibraryMirror] that represents their shared
* functionality.
*
* For the purposes of the mirrors library, these types are all
* object-like, in that they support method invocation and field
* access. Real Dart objects are represented by the [InstanceMirror]
* type.
*
* See [InstanceMirror], [ClassMirror], and [LibraryMirror].
*/
abstract class ObjectMirror implements Mirror {
/**
* Invokes the named function and returns a mirror on the result.
*
* Let *o* be the object reflected by this mirror, let *f* be the simple name
* of the member denoted by [memberName], let *a1, ..., an* be the elements
* of [positionalArguments], let *k1, ..., km* be the identifiers denoted by
* the elements of [namedArguments].keys, and let *v1, ..., vm* be the
* elements of [namedArguments].values. Then this method will perform the
* method invocation *o.f(a1, ..., an, k1: v1, ..., km: vm)* in a scope that
* has access to the private members of *o* (if *o* is a class or library) or
* the private members of the class of *o* (otherwise).
*
* If the invocation returns a result *r*, this method returns the result of
* calling [reflect]\(*r*\).
*
* If the invocation causes a compilation error the effect is the same as if
* a non-reflective compilation error had been encountered.
*
* If the invocation throws an exception *e* (that it does not catch), this
* method throws *e*.
*/
InstanceMirror invoke(Symbol memberName, List<dynamic> positionalArguments,
[Map<Symbol, dynamic> namedArguments = const <Symbol, dynamic>{}]);
/**
* Invokes a getter and returns a mirror on the result.
*
* The getter can be the implicit getter for a field or a user-defined getter
* method.
*
* Let *o* be the object reflected by this mirror,
* let *f* be the simple name of the getter denoted by [fieldName].
*
* Then this method will perform the getter invocation *o.f* in a scope that
* has access to the private members of *o* (if *o* is a class or library) or
* the private members of the class of *o* (otherwise).
*
* If this mirror is an [InstanceMirror], and [fieldName] denotes an instance
* method on its reflectee, the result of the invocation is an instance
* mirror on a closure corresponding to that method.
*
* If this mirror is a [LibraryMirror], and [fieldName] denotes a top-level
* method in the corresponding library, the result of the invocation is an
* instance mirror on a closure corresponding to that method.
*
* If this mirror is a [ClassMirror], and [fieldName] denotes a static method
* in the corresponding class, the result of the invocation is an instance
* mirror on a closure corresponding to that method.
*
* If the invocation returns a result *r*, this method returns the result of
* calling [reflect]\(*r*\).
*
* If the invocation causes a compilation error, the effect is the same as if
* a non-reflective compilation error had been encountered.
*
* If the invocation throws an exception *e* (that it does not catch), this
* method throws *e*.
*/
// TODO(ahe): Remove stuff about scope and private members. [fieldName] is a
// capability giving access to private members.
InstanceMirror getField(Symbol fieldName);
/**
* Invokes a setter and returns a mirror on the result.
*
* The setter may be either the implicit setter for a non-final field or a
* user-defined setter method.
*
* Let *o* be the object reflected by this mirror,
* let *f* be the simple name of the getter denoted by [fieldName],
* and let *a* be the object bound to [value].
*
* Then this method will perform the setter invocation *o.f = a* in a scope
* that has access to the private members of *o* (if *o* is a class or
* library) or the private members of the class of *o* (otherwise).
*
* If the invocation returns a result *r*, this method returns the result of
* calling [reflect]\([value]\).
*
* If the invocation causes a compilation error, the effect is the same as if
* a non-reflective compilation error had been encountered.
*
* If the invocation throws an exception *e* (that it does not catch) this
* method throws *e*.
*/
InstanceMirror setField(Symbol fieldName, dynamic value);
/**
* Performs [invocation] on the reflectee of this [ObjectMirror].
*
* Equivalent to
*
* if (invocation.isGetter) {
* return this.getField(invocation.memberName).reflectee;
* } else if (invocation.isSetter) {
* return this.setField(invocation.memberName,
* invocation.positionalArguments[0]).reflectee;
* } else {
* return this.invoke(invocation.memberName,
* invocation.positionalArguments,
* invocation.namedArguments).reflectee;
* }
*/
delegate(Invocation invocation);
}
/**
* An [InstanceMirror] reflects an instance of a Dart language object.
*/
abstract class InstanceMirror implements ObjectMirror {
/**
* A mirror on the type of the reflectee.
*
* Returns a mirror on the actual class of the reflectee.
* The class of the reflectee may differ from
* the object returned by invoking [runtimeType] on
* the reflectee.
*/
ClassMirror get type;
/**
* Whether [reflectee] will return the instance reflected by this mirror.
*
* This will always be true in the local case (reflecting instances in the
* same isolate), but only true in the remote case if this mirror reflects a
* simple value.
*
* A value is simple if one of the following holds:
*
* * the value is [:null:]
* * the value is of type [num]
* * the value is of type [bool]
* * the value is of type [String]
*/
bool get hasReflectee;
/**
* If the [InstanceMirror] reflects an instance it is meaningful to
* have a local reference to, we provide access to the actual
* instance here.
*
* If you access [reflectee] when [hasReflectee] is false, an
* exception is thrown.
*/
dynamic get reflectee;
/**
* Whether this mirror is equal to [other].
*
* The equality holds if and only if
*
* 1. [other] is a mirror of the same kind, and
* 2. either
*
* a. [hasReflectee] is true and so is
* [:identical(reflectee, other.reflectee):], or
*
* b. the remote objects reflected by this mirror and by [other] are
* identical.
*/
bool operator ==(Object other);
}
/**
* A [ClosureMirror] reflects a closure.
*
* A [ClosureMirror] provides the ability to execute its reflectee and
* introspect its function.
*/
abstract class ClosureMirror implements InstanceMirror {
/**
* A mirror on the function associated with this closure.
*
* The function associated with an implicit closure of a function is that
* function.
*
* The function associated with an instance of a class that has a [:call:]
* method is that [:call:] method.
*
* A Dart implementation might choose to create a class for each closure
* expression, in which case [:function:] would be the same as
* [:type.declarations[#call]:]. But the Dart language model does not require
* this. A more typical implementation involves a single closure class for
* each type signature, where the call method dispatches to a function held
* in the closure rather the call method
* directly implementing the closure body. So one cannot rely on closures from
* distinct closure expressions having distinct classes ([:type:]), but one
* can rely on them having distinct functions ([:function:]).
*/
MethodMirror get function;
/**
* Executes the closure and returns a mirror on the result.
*
* Let *f* be the closure reflected by this mirror,
* let *a1, ..., an* be the elements of [positionalArguments],
* let *k1, ..., km* be the identifiers denoted by the elements of
* [namedArguments].keys,
* and let *v1, ..., vm* be the elements of [namedArguments].values.
*
* Then this method will perform the method invocation
* *f(a1, ..., an, k1: v1, ..., km: vm)*.
*
* If the invocation returns a result *r*, this method returns the result of
* calling [reflect]\(*r*\).
*
* If the invocation causes a compilation error, the effect is the same as if
* a non-reflective compilation error had been encountered.
*
* If the invocation throws an exception *e* (that it does not catch), this
* method throws *e*.
*/
InstanceMirror apply(List<dynamic> positionalArguments,
[Map<Symbol, dynamic> namedArguments = const <Symbol, dynamic>{}]);
}
/**
* A [LibraryMirror] reflects a Dart language library, providing
* access to the variables, functions, and classes of the
* library.
*/
abstract class LibraryMirror implements DeclarationMirror, ObjectMirror {
/**
* The absolute uri of the library.
*/
Uri get uri;
/**
* Returns an immutable map of the declarations actually given in the library.
*
* This map includes all regular methods, getters, setters, fields, classes
* and typedefs actually declared in the library. The map is keyed by the
* simple names of the declarations.
*/
Map<Symbol, DeclarationMirror> get declarations;
/**
* Whether this mirror is equal to [other].
*
* The equality holds if and only if
*
* 1. [other] is a mirror of the same kind, and
* 2. The library being reflected by this mirror and the library being
* reflected by [other] are the same library in the same isolate.
*/
bool operator ==(Object other);
/**
* Returns a list of the imports and exports in this library;
*/
List<LibraryDependencyMirror> get libraryDependencies;
}
/// A mirror on an import or export declaration.
abstract class LibraryDependencyMirror implements Mirror {
/// Is `true` if this dependency is an import.
bool get isImport;
/// Is `true` if this dependency is an export.
bool get isExport;
/// Returns true iff this dependency is a deferred import. Otherwise returns
/// false.
bool get isDeferred;
/// Returns the library mirror of the library that imports or exports the
/// [targetLibrary].
LibraryMirror get sourceLibrary;
/// Returns the library mirror of the library that is imported or exported,
/// or null if the library is not loaded.
LibraryMirror? get targetLibrary;
/// Returns the prefix if this is a prefixed import and `null` otherwise.
Symbol? get prefix;
/// Returns the list of show/hide combinators on the import/export
/// declaration.
List<CombinatorMirror> get combinators;
/// Returns the source location for this import/export declaration.
SourceLocation? get location;
List<InstanceMirror> get metadata;
/// Returns a future that completes with a library mirror on the library being
/// imported or exported when it is loaded, and initiates a load of that
/// library if it is not loaded.
Future<LibraryMirror> loadLibrary();
}
/// A mirror on a show/hide combinator declared on a library dependency.
abstract class CombinatorMirror implements Mirror {
/// The list of identifiers on the combinator.
List<Symbol> get identifiers;
/// Is `true` if this is a 'show' combinator.
bool get isShow;
/// Is `true` if this is a 'hide' combinator.
bool get isHide;
}
/**
* A [TypeMirror] reflects a Dart language class, typedef,
* function type or type variable.
*/
abstract class TypeMirror implements DeclarationMirror {
/**
* Returns true if this mirror reflects dynamic, a non-generic class or
* typedef, or an instantiated generic class or typedef in the current
* isolate. Otherwise, returns false.
*/
bool get hasReflectedType;
/**
* If [:hasReflectedType:] returns true, returns the corresponding [Type].
* Otherwise, an [UnsupportedError] is thrown.
*/
Type get reflectedType;
/**
* An immutable list with mirrors for all type variables for this type.
*
* If this type is a generic declaration or an invocation of a generic
* declaration, the returned list contains mirrors on the type variables
* declared in the original declaration.
* Otherwise, the returned list is empty.
*
* This list preserves the order of declaration of the type variables.
*/
List<TypeVariableMirror> get typeVariables;
/**
* An immutable list with mirrors for all type arguments for
* this type.
*
* If the reflectee is an invocation of a generic class,
* the type arguments are the bindings of its type parameters.
* If the reflectee is the original declaration of a generic,
* it has no type arguments and this method returns an empty list.
* If the reflectee is not generic, then
* it has no type arguments and this method returns an empty list.
*
* This list preserves the order of declaration of the type variables.
*/
List<TypeMirror> get typeArguments;
/**
* Is this the original declaration of this type?
*
* For most classes, they are their own original declaration. For
* generic classes, however, there is a distinction between the
* original class declaration, which has unbound type variables, and
* the instantiations of generic classes, which have bound type
* variables.
*/
bool get isOriginalDeclaration;
/**
* A mirror on the original declaration of this type.
*
* For most classes, they are their own original declaration. For
* generic classes, however, there is a distinction between the
* original class declaration, which has unbound type variables, and
* the instantiations of generic classes, which have bound type
* variables.
*/
TypeMirror get originalDeclaration;
/**
* Checks the subtype relationship, denoted by `<:` in the language
* specification.
*
* This is the type relationship used in `is` test checks.
*/
bool isSubtypeOf(TypeMirror other);
/**
* Checks the assignability relationship, denoted by `<=>` in the language
* specification.
*
* This is the type relationship tested on assignment in checked mode.
*/
bool isAssignableTo(TypeMirror other);
}
/**
* A [ClassMirror] reflects a Dart language class.
*/
abstract class ClassMirror implements TypeMirror, ObjectMirror {
/**
* A mirror on the superclass on the reflectee.
*
* If this type is [:Object:], the superclass will be null.
*/
ClassMirror? get superclass;
/**
* A list of mirrors on the superinterfaces of the reflectee.
*/
List<ClassMirror> get superinterfaces;
/**
* Is the reflectee abstract?
*/
bool get isAbstract;
/**
* Is the reflectee an enum?
*/
bool get isEnum;
/**
* Returns an immutable map of the declarations actually given in the class
* declaration.
*
* This map includes all regular methods, getters, setters, fields,
* constructors and type variables actually declared in the class. Both
* static and instance members are included, but no inherited members are
* included. The map is keyed by the simple names of the declarations.
*
* This does not include inherited members.
*/
Map<Symbol, DeclarationMirror> get declarations;
/**
* Returns a map of the methods, getters and setters of an instance of the
* class.
*
* The intent is to capture those members that constitute the API of an
* instance. Hence fields are not included, but the getters and setters
* implicitly introduced by fields are included. The map includes methods,
* getters and setters that are inherited as well as those introduced by the
* class itself.
*
* The map is keyed by the simple names of the members.
*/
Map<Symbol, MethodMirror> get instanceMembers;
/**
* Returns a map of the static methods, getters and setters of the class.
*
* The intent is to capture those members that constitute the API of a class.
* Hence fields are not included, but the getters and setters implicitly
* introduced by fields are included.
*
* The map is keyed by the simple names of the members.
*/
Map<Symbol, MethodMirror> get staticMembers;
/**
* The mixin of this class.
*
* If this class is the result of a mixin application of the form S with M,
* returns a class mirror on M. Otherwise returns a class mirror on
* the reflectee.
*/
ClassMirror get mixin;
/**
* Invokes the named constructor and returns a mirror on the result.
*
* Let *c* be the class reflected by this mirror,
* let *a1, ..., an* be the elements of [positionalArguments],
* let *k1, ..., km* be the identifiers denoted by the elements of
* [namedArguments].keys,
* and let *v1, ..., vm* be the elements of [namedArguments].values.
*
* If [constructorName] was created from the empty string, then this method
* will execute the instance creation expression
* *new c(a1, ..., an, k1: v1, ..., km: vm)* in a scope that has access to
* the private members of *c*.
*
* Otherwise, let *f* be the simple name of the constructor denoted by
* [constructorName]. Then this method will execute the instance creation
* expression *new c.f(a1, ..., an, k1: v1, ..., km: vm)* in a scope that has
* access to the private members of *c*.
*
* In either case:
*
* * If the expression evaluates to a result *r*, this method returns the
* result of calling [reflect]\(*r*\).
* * If evaluating the expression causes a compilation error, the effect is
* the same as if a non-reflective compilation error had been encountered.
* * If evaluating the expression throws an exception *e* (that it does not
* catch), this method throws *e*.
*/
InstanceMirror newInstance(
Symbol constructorName, List<dynamic> positionalArguments,
[Map<Symbol, dynamic> namedArguments = const <Symbol, dynamic>{}]);
/**
* Whether this mirror is equal to [other].
*
* The equality holds if and only if
*
* 1. [other] is a mirror of the same kind, and
* 2. This mirror and [other] reflect the same class.
*
* Note that if the reflected class is an invocation of a generic class, 2.
* implies that the reflected class and [other] have equal type arguments.
*/
bool operator ==(Object other);
/**
* Returns whether the class denoted by the receiver is a subclass of the
* class denoted by the argument.
*
* Note that the subclass relationship is reflexive.
*/
bool isSubclassOf(ClassMirror other);
}
/**
* A [FunctionTypeMirror] represents the type of a function in the
* Dart language.
*/
abstract class FunctionTypeMirror implements ClassMirror {
/**
* Returns the return type of the reflectee.
*/
TypeMirror get returnType;
/**
* Returns a list of the parameter types of the reflectee.
*/
List<ParameterMirror> get parameters;
/**
* A mirror on the [:call:] method for the reflectee.
*/
// This is only here because in the past the VM did not implement a call
// method on closures.
MethodMirror get callMethod;
}
/**
* A [TypeVariableMirror] represents a type parameter of a generic type.
*/
abstract class TypeVariableMirror extends TypeMirror {
/**
* A mirror on the type that is the upper bound of this type variable.
*/
TypeMirror get upperBound;
/**
* Is the reflectee static?
*
* For the purposes of the mirrors library, type variables are considered
* non-static.
*/
bool get isStatic;
/**
* Whether [other] is a [TypeVariableMirror] on the same type variable as this
* mirror.
*
* The equality holds if and only if
*
* 1. [other] is a mirror of the same kind, and
* 2. [:simpleName == other.simpleName:] and [:owner == other.owner:].
*/
bool operator ==(Object other);
}
/**
* A [TypedefMirror] represents a typedef in a Dart language program.
*/
abstract class TypedefMirror implements TypeMirror {
/**
* The defining type for this typedef.
*
* If the type referred to by the reflectee is a function type *F*, the
* result will be [:FunctionTypeMirror:] reflecting *F* which is abstract
* and has an abstract method [:call:] whose signature corresponds to *F*.
* For instance [:void f(int):] is the referent for [:typedef void f(int):].
*/
FunctionTypeMirror get referent;
}
/**
* A [MethodMirror] reflects a Dart language function, method,
* constructor, getter, or setter.
*/
abstract class MethodMirror implements DeclarationMirror {
/**
* A mirror on the return type for the reflectee.
*/
TypeMirror get returnType;
/**
* The source code for the reflectee, if available. Otherwise null.
*/
String? get source;
/**
* A list of mirrors on the parameters for the reflectee.
*/
List<ParameterMirror> get parameters;
/**
* A function is considered non-static iff it is permited to refer to 'this'.
*
* Note that generative constructors are considered non-static, whereas
* factory constructors are considered static.
*/
bool get isStatic;
/**