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
|
# -*- 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_pass3)
self._namespace.walk(self._remove_non_reachable_backcompat_copies)
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.get_tag(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: %r" % (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 not node.type.target_giname 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)")
% (ast.PARAM_SCOPE_CALL, ast.PARAM_SCOPE_ASYNC))
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)
if typeval.is_equiv((ast.TYPE_LONG_LONG, ast.TYPE_LONG_ULONG,
ast.TYPE_LONG_DOUBLE)):
return False
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
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 prop in obj.properties:
if not self._type_is_introspectable(prop.type):
prop.introspectable = False
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 not obj.introspectable
and obj.moved_to is not None):
self._namespace.remove(obj)
return True
|
