@@ -72,66 +72,66 @@ class GeneratorFrontEnd implements Generator {
72
72
var indexAccumulator = < Indexable > [];
73
73
var multiplePackages = packageGraph.localPackages.length > 1 ;
74
74
75
- void generateConstants (Container container) {
75
+ void generateConstants (Container container, Library library ) {
76
76
for (var constant in container.constantFields.whereDocumented) {
77
77
if (! constant.isCanonical) continue ;
78
78
indexAccumulator.add (constant);
79
79
_generatorBackend.generateProperty (
80
- packageGraph, container. library, container, constant);
80
+ packageGraph, library, container, constant);
81
81
}
82
82
}
83
83
84
- void generateConstructors (Constructable constructable) {
84
+ void generateConstructors (Constructable constructable, Library library ) {
85
85
for (var constructor in constructable.constructors.whereDocumented) {
86
86
if (! constructor.isCanonical) continue ;
87
87
indexAccumulator.add (constructor);
88
88
_generatorBackend.generateConstructor (
89
- packageGraph, constructable. library, constructable, constructor);
89
+ packageGraph, library, constructable, constructor);
90
90
}
91
91
}
92
92
93
- void generateInstanceMethods (Container container) {
93
+ void generateInstanceMethods (Container container, Library library ) {
94
94
for (var method in container.instanceMethods.whereDocumented) {
95
95
if (! method.isCanonical) continue ;
96
96
indexAccumulator.add (method);
97
97
_generatorBackend.generateMethod (
98
- packageGraph, container. library, container, method);
98
+ packageGraph, library, container, method);
99
99
}
100
100
}
101
101
102
- void generateInstanceOperators (Container container) {
102
+ void generateInstanceOperators (Container container, Library library ) {
103
103
for (var operator in container.instanceOperators.whereDocumented) {
104
104
if (! operator .isCanonical) continue ;
105
105
indexAccumulator.add (operator );
106
106
_generatorBackend.generateMethod (
107
- packageGraph, container. library, container, operator );
107
+ packageGraph, library, container, operator );
108
108
}
109
109
}
110
110
111
- void generateInstanceProperties (Container container) {
111
+ void generateInstanceProperties (Container container, Library library ) {
112
112
for (var property in container.instanceFields.whereDocumented) {
113
113
if (! property.isCanonical) continue ;
114
114
indexAccumulator.add (property);
115
115
_generatorBackend.generateProperty (
116
- packageGraph, container. library, container, property);
116
+ packageGraph, library, container, property);
117
117
}
118
118
}
119
119
120
- void generateStaticMethods (Container container) {
120
+ void generateStaticMethods (Container container, Library library ) {
121
121
for (var method in container.staticMethods.whereDocumented) {
122
122
if (! method.isCanonical) continue ;
123
123
indexAccumulator.add (method);
124
124
_generatorBackend.generateMethod (
125
- packageGraph, container. library, container, method);
125
+ packageGraph, library, container, method);
126
126
}
127
127
}
128
128
129
- void generateStaticProperties (Container container) {
129
+ void generateStaticProperties (Container container, Library library ) {
130
130
for (var property in container.variableStaticFields.whereDocumented) {
131
131
if (! property.isCanonical) continue ;
132
132
indexAccumulator.add (property);
133
133
_generatorBackend.generateProperty (
134
- packageGraph, container. library, container, property);
134
+ packageGraph, library, container, property);
135
135
}
136
136
}
137
137
@@ -157,88 +157,113 @@ class GeneratorFrontEnd implements Generator {
157
157
indexAccumulator.add (lib);
158
158
_generatorBackend.generateLibrary (packageGraph, lib);
159
159
160
- for (var class_ in lib.classesAndExceptions.whereDocumented ) {
160
+ for (var class_ in lib.classesAndExceptions.whereDocumentedIn (lib) ) {
161
161
indexAccumulator.add (class_);
162
162
_generatorBackend.generateClass (packageGraph, lib, class_);
163
163
164
- generateConstants (class_);
165
- generateConstructors (class_);
166
- generateInstanceMethods (class_);
167
- generateInstanceOperators (class_);
168
- generateInstanceProperties (class_);
169
- generateStaticMethods (class_);
170
- generateStaticProperties (class_);
164
+ var canonicalLibrary = class_.canonicalLibrary;
165
+ if (canonicalLibrary == null ) {
166
+ throw StateError ("Cannot generate docs for '$class_ ' (in "
167
+ "'${class_ .library }'), as it has no canonical library" );
168
+ }
169
+ generateConstants (class_, canonicalLibrary);
170
+ generateConstructors (class_, canonicalLibrary);
171
+ generateInstanceMethods (class_, canonicalLibrary);
172
+ generateInstanceOperators (class_, canonicalLibrary);
173
+ generateInstanceProperties (class_, canonicalLibrary);
174
+ generateStaticMethods (class_, canonicalLibrary);
175
+ generateStaticProperties (class_, canonicalLibrary);
171
176
}
172
177
173
- for (var extension in lib.extensions.whereDocumented ) {
178
+ for (var extension in lib.extensions.whereDocumentedIn (lib) ) {
174
179
indexAccumulator.add (extension );
175
180
_generatorBackend.generateExtension (packageGraph, lib, extension );
176
181
177
- generateConstants (extension );
178
- generateInstanceMethods (extension );
179
- generateInstanceOperators (extension );
180
- generateInstanceProperties (extension );
181
- generateStaticMethods (extension );
182
- generateStaticProperties (extension );
182
+ var canonicalLibrary = extension .canonicalLibrary;
183
+ if (canonicalLibrary == null ) {
184
+ throw StateError ("Cannot generate docs for '$extension ' (in "
185
+ "'${extension .library }'), as it has no canonical library" );
186
+ }
187
+ generateConstants (extension , canonicalLibrary);
188
+ generateInstanceMethods (extension , canonicalLibrary);
189
+ generateInstanceOperators (extension , canonicalLibrary);
190
+ generateInstanceProperties (extension , canonicalLibrary);
191
+ generateStaticMethods (extension , canonicalLibrary);
192
+ generateStaticProperties (extension , canonicalLibrary);
183
193
}
184
194
185
- for (var extensionType in lib.extensionTypes.whereDocumented ) {
195
+ for (var extensionType in lib.extensionTypes.whereDocumentedIn (lib) ) {
186
196
indexAccumulator.add (extensionType);
187
197
_generatorBackend.generateExtensionType (
188
198
packageGraph, lib, extensionType);
189
199
190
- generateConstants (extensionType);
191
- generateConstructors (extensionType);
192
- generateInstanceMethods (extensionType);
193
- generateInstanceOperators (extensionType);
194
- generateInstanceProperties (extensionType);
195
- generateStaticMethods (extensionType);
196
- generateStaticProperties (extensionType);
200
+ var canonicalLibrary = extensionType.canonicalLibrary;
201
+ if (canonicalLibrary == null ) {
202
+ throw StateError ("Cannot generate docs for '$extensionType ' (in "
203
+ "'${extensionType .library }'), as it has no canonical library" );
204
+ }
205
+ generateConstants (extensionType, canonicalLibrary);
206
+ generateConstructors (extensionType, canonicalLibrary);
207
+ generateInstanceMethods (extensionType, canonicalLibrary);
208
+ generateInstanceOperators (extensionType, canonicalLibrary);
209
+ generateInstanceProperties (extensionType, canonicalLibrary);
210
+ generateStaticMethods (extensionType, canonicalLibrary);
211
+ generateStaticProperties (extensionType, canonicalLibrary);
197
212
}
198
213
199
- for (var mixin in lib.mixins.whereDocumented ) {
214
+ for (var mixin in lib.mixins.whereDocumentedIn (lib) ) {
200
215
indexAccumulator.add (mixin );
201
216
_generatorBackend.generateMixin (packageGraph, lib, mixin );
202
217
203
- generateConstants (mixin );
204
- generateInstanceMethods (mixin );
205
- generateInstanceOperators (mixin );
206
- generateInstanceProperties (mixin );
207
- generateStaticMethods (mixin );
208
- generateStaticProperties (mixin );
218
+ var canonicalLibrary = mixin .canonicalLibrary;
219
+ if (canonicalLibrary == null ) {
220
+ throw StateError ("Cannot generate docs for '$mixin ' (in "
221
+ "'${mixin .library }'), as it has no canonical library" );
222
+ }
223
+ generateConstants (mixin , canonicalLibrary);
224
+ generateInstanceMethods (mixin , canonicalLibrary);
225
+ generateInstanceOperators (mixin , canonicalLibrary);
226
+ generateInstanceProperties (mixin , canonicalLibrary);
227
+ generateStaticMethods (mixin , canonicalLibrary);
228
+ generateStaticProperties (mixin , canonicalLibrary);
209
229
}
210
230
211
- for (var enum_ in lib.enums.whereDocumented ) {
231
+ for (var enum_ in lib.enums.whereDocumentedIn (lib) ) {
212
232
indexAccumulator.add (enum_);
213
233
_generatorBackend.generateEnum (packageGraph, lib, enum_);
214
234
215
- generateConstants (enum_);
216
- generateConstructors (enum_);
217
- generateInstanceMethods (enum_);
218
- generateInstanceOperators (enum_);
219
- generateInstanceProperties (enum_);
220
- generateStaticMethods (enum_);
221
- generateStaticProperties (enum_);
235
+ var canonicalLibrary = enum_.canonicalLibrary;
236
+ if (canonicalLibrary == null ) {
237
+ throw StateError ("Cannot generate docs for '$enum_ ' (in "
238
+ "'${enum_ .library }'), as it has no canonical library" );
239
+ }
240
+ generateConstants (enum_, canonicalLibrary);
241
+ generateConstructors (enum_, canonicalLibrary);
242
+ generateInstanceMethods (enum_, canonicalLibrary);
243
+ generateInstanceOperators (enum_, canonicalLibrary);
244
+ generateInstanceProperties (enum_, canonicalLibrary);
245
+ generateStaticMethods (enum_, canonicalLibrary);
246
+ generateStaticProperties (enum_, canonicalLibrary);
222
247
}
223
248
224
- for (var constant in lib.constants.whereDocumented ) {
249
+ for (var constant in lib.constants.whereDocumentedIn (lib) ) {
225
250
indexAccumulator.add (constant);
226
251
_generatorBackend.generateTopLevelProperty (
227
252
packageGraph, lib, constant);
228
253
}
229
254
230
- for (var property in lib.properties.whereDocumented ) {
255
+ for (var property in lib.properties.whereDocumentedIn (lib) ) {
231
256
indexAccumulator.add (property);
232
257
_generatorBackend.generateTopLevelProperty (
233
258
packageGraph, lib, property);
234
259
}
235
260
236
- for (var function in lib.functions.whereDocumented ) {
261
+ for (var function in lib.functions.whereDocumentedIn (lib) ) {
237
262
indexAccumulator.add (function);
238
263
_generatorBackend.generateFunction (packageGraph, lib, function);
239
264
}
240
265
241
- for (var typeDef in lib.typedefs.whereDocumented ) {
266
+ for (var typeDef in lib.typedefs.whereDocumentedIn (lib) ) {
242
267
indexAccumulator.add (typeDef);
243
268
_generatorBackend.generateTypeDef (packageGraph, lib, typeDef);
244
269
}
0 commit comments