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 #library('mirrors.util'); | 5 #library('mirrors.util'); |
6 | 6 |
7 // TODO(rnystrom): Use "package:" URL (#4968). | 7 // TODO(rnystrom): Use "package:" URL (#4968). |
8 #import('mirrors.dart'); | 8 #import('mirrors.dart'); |
9 #import('../../../lib/compiler/implementation/util/characters.dart'); | 9 #import('../../../lib/compiler/implementation/util/characters.dart'); |
10 | 10 |
11 //------------------------------------------------------------------------------ | 11 //------------------------------------------------------------------------------ |
12 // Utility functions for using the Mirror API | 12 // Utility functions for using the Mirror API |
13 //------------------------------------------------------------------------------ | 13 //------------------------------------------------------------------------------ |
14 | 14 |
15 /** | 15 /** |
16 * Returns an iterable over the type declarations directly inheriting from | 16 * Returns an iterable over the type declarations directly inheriting from |
17 * the declaration of this type. | 17 * the declaration of this type. |
18 */ | 18 */ |
19 Iterable<InterfaceMirror> computeSubdeclarations(InterfaceMirror type) { | 19 Iterable<ClassMirror> computeSubdeclarations(ClassMirror type) { |
20 type = type.declaration; | 20 type = type.declaration; |
21 var subtypes = <InterfaceMirror>[]; | 21 var subtypes = <ClassMirror>[]; |
22 type.system.libraries.forEach((_, library) { | 22 type.system.libraries.forEach((_, library) { |
23 for (InterfaceMirror otherType in library.types.values) { | 23 for (ClassMirror otherType in library.types.values) { |
24 var superClass = otherType.superclass; | 24 var superClass = otherType.superclass; |
25 if (superClass !== null) { | 25 if (superClass !== null) { |
26 superClass = superClass.declaration; | 26 superClass = superClass.declaration; |
27 if (type.library === superClass.library) { | 27 if (type.library === superClass.library) { |
28 if (superClass == type) { | 28 if (superClass == type) { |
29 subtypes.add(otherType); | 29 subtypes.add(otherType); |
30 } | 30 } |
31 } | 31 } |
32 } | 32 } |
33 final superInterfaces = otherType.interfaces; | 33 final superInterfaces = otherType.interfaces; |
34 for (InterfaceMirror superInterface in superInterfaces) { | 34 for (ClassMirror superInterface in superInterfaces) { |
35 superInterface = superInterface.declaration; | 35 superInterface = superInterface.declaration; |
36 if (type.library === superInterface.library) { | 36 if (type.library === superInterface.library) { |
37 if (superInterface == type) { | 37 if (superInterface == type) { |
38 subtypes.add(otherType); | 38 subtypes.add(otherType); |
39 } | 39 } |
40 } | 40 } |
41 } | 41 } |
42 } | 42 } |
43 }); | 43 }); |
44 return subtypes; | 44 return subtypes; |
(...skipping 21 matching lines...) Expand all Loading... |
66 var charCode = text.charCodeAt(index); | 66 var charCode = text.charCodeAt(index); |
67 if (charCode == $CR || charCode == $LF) { | 67 if (charCode == $CR || charCode == $LF) { |
68 break; | 68 break; |
69 } | 69 } |
70 index--; | 70 index--; |
71 column++; | 71 column++; |
72 } | 72 } |
73 return column; | 73 return column; |
74 } | 74 } |
75 | 75 |
76 class HierarchyIterable implements Iterable<InterfaceMirror> { | 76 class HierarchyIterable implements Iterable<ClassMirror> { |
77 final bool includeType; | 77 final bool includeType; |
78 final InterfaceMirror type; | 78 final ClassMirror type; |
79 | 79 |
80 HierarchyIterable(this.type, {bool includeType}) | 80 HierarchyIterable(this.type, {bool includeType}) |
81 : this.includeType = includeType; | 81 : this.includeType = includeType; |
82 | 82 |
83 Iterator<InterfaceMirror> iterator() => | 83 Iterator<ClassMirror> iterator() => |
84 new HierarchyIterator(type, includeType: includeType); | 84 new HierarchyIterator(type, includeType: includeType); |
85 } | 85 } |
86 | 86 |
87 /** | 87 /** |
88 * [HierarchyIterator] iterates through the class hierarchy of the provided | 88 * [HierarchyIterator] iterates through the class hierarchy of the provided |
89 * type. | 89 * type. |
90 * | 90 * |
91 * First is the superclass relation is traversed, skipping [Object], next the | 91 * First is the superclass relation is traversed, skipping [Object], next the |
92 * superinterface relation and finally is [Object] visited. The supertypes are | 92 * superinterface relation and finally is [Object] visited. The supertypes are |
93 * visited in breadth first order and a superinterface is visited more than once | 93 * visited in breadth first order and a superinterface is visited more than once |
94 * if implemented through multiple supertypes. | 94 * if implemented through multiple supertypes. |
95 */ | 95 */ |
96 class HierarchyIterator implements Iterator<InterfaceMirror> { | 96 class HierarchyIterator implements Iterator<ClassMirror> { |
97 final Queue<InterfaceMirror> queue = new Queue<InterfaceMirror>(); | 97 final Queue<ClassMirror> queue = new Queue<ClassMirror>(); |
98 InterfaceMirror object; | 98 ClassMirror object; |
99 | 99 |
100 HierarchyIterator(InterfaceMirror type, {bool includeType}) { | 100 HierarchyIterator(ClassMirror type, {bool includeType}) { |
101 if (includeType) { | 101 if (includeType) { |
102 queue.add(type); | 102 queue.add(type); |
103 } else { | 103 } else { |
104 push(type); | 104 push(type); |
105 } | 105 } |
106 } | 106 } |
107 | 107 |
108 InterfaceMirror push(InterfaceMirror type) { | 108 ClassMirror push(ClassMirror type) { |
109 if (type.superclass !== null) { | 109 if (type.superclass !== null) { |
110 if (type.superclass.isObject) { | 110 if (type.superclass.isObject) { |
111 object = type.superclass; | 111 object = type.superclass; |
112 } else { | 112 } else { |
113 queue.addFirst(type.superclass); | 113 queue.addFirst(type.superclass); |
114 } | 114 } |
115 } | 115 } |
116 queue.addAll(type.interfaces); | 116 queue.addAll(type.interfaces); |
117 return type; | 117 return type; |
118 } | 118 } |
119 | 119 |
120 InterfaceMirror next() { | 120 ClassMirror next() { |
121 InterfaceMirror type; | 121 ClassMirror type; |
122 if (queue.isEmpty) { | 122 if (queue.isEmpty) { |
123 if (object === null) { | 123 if (object === null) { |
124 throw new StateError("No more elements"); | 124 throw new StateError("No more elements"); |
125 } | 125 } |
126 type = object; | 126 type = object; |
127 object = null; | 127 object = null; |
128 return type; | 128 return type; |
129 } else { | 129 } else { |
130 return push(queue.removeFirst()); | 130 return push(queue.removeFirst()); |
131 } | 131 } |
132 } | 132 } |
133 | 133 |
134 bool get hasNext => !queue.isEmpty || object !== null; | 134 bool get hasNext => !queue.isEmpty || object !== null; |
135 } | 135 } |
OLD | NEW |