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
|
# -*- Mode: Python -*-
# Copyright (C) 2010 Red Hat, Inc.
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the
# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
# Boston, MA 02111-1307, USA.
#
from . import ast
from . import message
from .annotationparser import TAG_RETURNS
class IntrospectablePass(object):
def __init__(self, transformer, blocks):
self._transformer = transformer
self._namespace = transformer.namespace
self._blocks = blocks
# Public API
def validate(self):
self._namespace.walk(self._introspectable_alias_analysis)
self._namespace.walk(self._propagate_callable_skips)
self._namespace.walk(self._analyze_node)
self._namespace.walk(self._introspectable_callable_analysis)
self._namespace.walk(self._introspectable_callable_analysis)
self._namespace.walk(self._introspectable_property_analysis)
self._namespace.walk(self._introspectable_pass3)
self._namespace.walk(self._remove_non_reachable_backcompat_copies)
self._namespace.walk(self._introspectable_symbol_collisions)
def _parameter_warning(self, parent, param, text, position=None):
# Suppress VFunctions and Callbacks warnings for now
# they cause more problems then they are worth
if isinstance(parent, (ast.VFunction, ast.Callback)):
return
block = None
if hasattr(parent, 'symbol'):
prefix = '%s: ' % (parent.symbol, )
block = self._blocks.get(parent.symbol)
if block:
position = block.position
else:
prefix = ''
if isinstance(param, ast.Parameter):
context = "argument %s: " % (param.argname, )
else:
context = "return value: "
if block:
return_tag = block.tags.get(TAG_RETURNS)
if return_tag:
position = return_tag.position
message.warn_node(parent, prefix + context + text,
positions=position)
def _introspectable_param_analysis(self, parent, node):
is_return = isinstance(node, ast.Return)
is_parameter = isinstance(node, ast.Parameter)
assert is_return or is_parameter
if node.type.target_giname is not None:
target = self._transformer.lookup_typenode(node.type)
else:
target = None
if node.skip:
return
if not node.type.resolved:
self._parameter_warning(parent, node,
"Unresolved type: '%s'" % (node.type.unresolved_string, ))
parent.introspectable = False
return
if isinstance(node.type, ast.Varargs):
parent.introspectable = False
return
if (isinstance(node.type, (ast.List, ast.Array))
and node.type.element_type == ast.TYPE_ANY):
self._parameter_warning(parent, node, "Missing (element-type) annotation")
parent.introspectable = False
return
if (is_parameter
and isinstance(target, ast.Callback)
and node.type.target_giname not in ('GLib.DestroyNotify', 'Gio.AsyncReadyCallback')
and node.scope is None):
self._parameter_warning(
parent,
node,
"Missing (scope) annotation for callback without "
"GDestroyNotify (valid: %s, %s, %s)" % (ast.PARAM_SCOPE_CALL, ast.PARAM_SCOPE_ASYNC, ast.PARAM_SCOPE_FOREVER))
parent.introspectable = False
return
if is_return and isinstance(target, ast.Callback):
self._parameter_warning(parent, node, "Callbacks cannot be return values; use (skip)")
parent.introspectable = False
return
if (is_return
and isinstance(target, (ast.Record, ast.Union))
and target.get_type is None
and not target.foreign):
if node.transfer != ast.PARAM_TRANSFER_NONE:
self._parameter_warning(
parent, node,
"Invalid non-constant return of bare structure or union; "
"register as boxed type or (skip)")
parent.introspectable = False
return
if node.transfer is None:
self._parameter_warning(parent, node, "Missing (transfer) annotation")
parent.introspectable = False
return
def _type_is_introspectable(self, typeval, warn=False):
if not typeval.resolved:
return False
if isinstance(typeval, ast.TypeUnknown):
return False
if isinstance(typeval, (ast.Array, ast.List)):
return self._type_is_introspectable(typeval.element_type)
elif isinstance(typeval, ast.Map):
return (self._type_is_introspectable(typeval.key_type)
and self._type_is_introspectable(typeval.value_type))
if typeval.target_foreign:
return True
if typeval.target_fundamental:
if typeval.is_equiv(ast.TYPE_VALIST):
return False
# These are not introspectable pending us adding
# larger type tags to the typelib (in theory these could
# be 128 bit or larger)
elif typeval.is_equiv((ast.TYPE_LONG_LONG, ast.TYPE_LONG_ULONG, ast.TYPE_LONG_DOUBLE)):
return False
else:
return True
target = self._transformer.lookup_typenode(typeval)
if not target:
return False
return target.introspectable and (not target.skip)
def _propagate_parameter_skip(self, parent, node):
if node.type.target_giname is not None:
target = self._transformer.lookup_typenode(node.type)
if target is None:
return
else:
return
if target.skip:
parent.skip = True
def _introspectable_alias_analysis(self, obj, stack):
if isinstance(obj, ast.Alias):
if not self._type_is_introspectable(obj.target):
obj.introspectable = False
return True
def _propagate_callable_skips(self, obj, stack):
if isinstance(obj, ast.Callable):
for param in obj.parameters:
self._propagate_parameter_skip(obj, param)
self._propagate_parameter_skip(obj, obj.retval)
return True
def _analyze_node(self, obj, stack):
if obj.skip:
return False
# Our first pass for scriptability
if isinstance(obj, ast.Callable):
for param in obj.parameters:
self._introspectable_param_analysis(obj, param)
self._introspectable_param_analysis(obj, obj.retval)
if isinstance(obj, (ast.Class, ast.Interface, ast.Record, ast.Union)):
for field in obj.fields:
if field.type:
if not self._type_is_introspectable(field.type):
field.introspectable = False
return True
def _introspectable_callable_analysis(self, obj, stack):
if obj.skip:
return False
# Propagate introspectability of parameters to entire functions
if isinstance(obj, ast.Callable):
for param in obj.parameters:
if not self._type_is_introspectable(param.type):
obj.introspectable = False
return True
if not self._type_is_introspectable(obj.retval.type):
obj.introspectable = False
return True
if isinstance(obj, ast.Signal):
if obj.emitter is None:
return False
parent = stack[0]
for method in parent.methods:
if method.name != obj.emitter:
continue
if not obj.retval.type.is_equiv(method.retval.type):
self._parameter_warning(
parent,
obj,
"Emitter method %s for signal %s::%s does not have the "
"same return value type" % (method.symbol, parent.name, obj.name))
obj.emitter = None
return False
n_emitter_params = len(method.parameters)
n_signal_params = len(obj.parameters)
if n_emitter_params != n_signal_params:
self._parameter_warning(
parent,
obj,
"Emitter method %s for signal %s::%s does not have the "
"same number of arguments (expected: %d)" % (method.symbol, parent.name, obj.name, n_signal_params))
obj.emitter = None
return False
for idx, signal_param in enumerate(obj.parameters):
method_param = method.parameters[idx + 1]
if signal_param.type.is_equiv(method_param.type):
self._parameter_warning(
parent,
obj,
"Emitter method %s for signal %s::%s does not have the "
"same type of arguments" % (method.symbol, parent.name, obj.name))
obj.emitter = None
return False
return True
def _introspectable_property_analysis(self, obj, stack):
if obj.skip:
return False
if isinstance(obj, (ast.Class, ast.Interface)):
for prop in obj.properties:
if not self._type_is_introspectable(prop.type):
prop.introspectable = False
prop.setter = None
prop.getter = None
for method in obj.methods:
set_property = method.set_property
if set_property is not None:
for prop in obj.properties:
if prop.name == set_property and not prop.introspectable:
method.set_property = None
break
get_property = method.get_property
if get_property is not None:
for prop in obj.properties:
if prop.name == get_property and not prop.introspectable:
method.get_property = None
break
return True
def _introspectable_pass3(self, obj, stack):
if obj.skip:
return False
# Propagate introspectability for fields
if isinstance(obj, (ast.Class, ast.Interface, ast.Record, ast.Union)):
for field in obj.fields:
if field.anonymous_node:
if not field.anonymous_node.introspectable:
field.introspectable = False
else:
if not self._type_is_introspectable(field.type):
field.introspectable = False
# Propagate introspectability for properties
if isinstance(obj, (ast.Class, ast.Interface)):
for sig in obj.signals:
self._introspectable_callable_analysis(sig, [obj])
return True
def _remove_non_reachable_backcompat_copies(self, obj, stack):
if obj.skip:
return False
if (isinstance(obj, ast.Function) and obj.moved_to is not None):
# remove functions that are not introspectable
if not obj.introspectable:
obj.internal_skipped = True
return True
def _property_warning(self, parent, prop, text, position=None):
context = "property %s:%s: " % (parent.name, prop.name, )
message.strict_node(parent, context + text, positions=position)
def _property_signal_collision(self, obj, prop):
for s in obj.signals:
if s.skip or not s.introspectable:
continue
if s.name.replace('-', '_') == prop.name.replace('-', '_'):
self._property_warning(obj, prop, "Properties cannot have the same name as signals")
prop.introspectable = False
return False
def _property_method_collision(self, obj, prop):
for m in obj.methods:
if m.skip or not m.introspectable:
continue
if m.name == prop.name.replace('-', '_'):
self._property_warning(obj, prop, "Properties cannot have the same name as methods")
prop.introspectable = False
return False
def _property_vfunc_collision(self, obj, prop):
for vfunc in obj.virtual_methods:
if vfunc.skip or not vfunc.introspectable:
continue
if vfunc.name == prop.name.replace('-', '_'):
self._property_warning(obj, prop, "Properties cannot have the same name as virtual methods")
prop.introspectable = False
return False
def _introspectable_symbol_collisions(self, obj, stack):
if obj.skip:
return False
if isinstance(obj, (ast.Class, ast.Interface)):
for prop in obj.properties:
if prop.skip or not prop.introspectable:
continue
self._property_signal_collision(obj, prop)
self._property_method_collision(obj, prop)
self._property_vfunc_collision(obj, prop)
return True
|