1 #!/usr/bin/env python 2 3 """ 4 Result abstractions. 5 6 Copyright (C) 2016, 2017 Paul Boddie <paul@boddie.org.uk> 7 8 This program is free software; you can redistribute it and/or modify it under 9 the terms of the GNU General Public License as published by the Free Software 10 Foundation; either version 3 of the License, or (at your option) any later 11 version. 12 13 This program is distributed in the hope that it will be useful, but WITHOUT 14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 15 FOR A PARTICULAR PURPOSE. See the GNU General Public License for more 16 details. 17 18 You should have received a copy of the GNU General Public License along with 19 this program. If not, see <http://www.gnu.org/licenses/>. 20 """ 21 22 from referencing import Reference 23 24 # Classes representing inspection and translation observations. 25 26 class Result: 27 28 "An abstract expression result." 29 30 def is_name(self): 31 return False 32 33 def is_global_name(self): 34 return False 35 36 def reference(self): 37 return None 38 39 def references(self): 40 return None 41 42 def access_location(self): 43 return None 44 45 def context_identity(self): 46 return None 47 48 def get_name(self): 49 return None 50 51 def get_origin(self): 52 return None 53 54 def static(self): 55 return None 56 57 def final(self): 58 return None 59 60 def has_kind(self, kinds): 61 return False 62 63 class AccessRef(Result): 64 65 """ 66 A reference to an attribute access that is generally only returned from a 67 processed access for possible initialiser resolution for assignments. 68 """ 69 70 def __init__(self, original_name, attrnames, number): 71 self.original_name = original_name 72 self.attrnames = attrnames 73 self.number = number 74 75 def __repr__(self): 76 return "AccessRef(%r, %r, %r)" % (self.original_name, self.attrnames, self.number) 77 78 class InvocationRef(Result): 79 80 "An invocation of a name reference." 81 82 def __init__(self, name_ref): 83 self.name_ref = name_ref 84 85 def reference(self): 86 origin = self.name_ref.get_origin() 87 if origin: 88 return Reference("<invoke>", origin) 89 else: 90 return Reference("<var>") 91 92 def __repr__(self): 93 return "InvocationRef(%r)" % self.name_ref 94 95 class NameRef(Result): 96 97 "A reference to a name." 98 99 def __init__(self, name, expr=None, is_global=False): 100 self.name = name 101 self.expr = expr 102 self.is_global = is_global 103 104 def is_name(self): 105 return True 106 107 def is_global_name(self): 108 return self.is_global 109 110 def final(self): 111 return None 112 113 def __repr__(self): 114 return "NameRef(%r, %r, %r)" % (self.name, self.expr, self.is_global) 115 116 class LocalNameRef(NameRef): 117 118 "A reference to a local name." 119 120 def __init__(self, name, number): 121 NameRef.__init__(self, name, is_global=False) 122 self.number = number 123 124 def __repr__(self): 125 return "LocalNameRef(%r, %r)" % (self.name, self.number) 126 127 class ResolvedRef: 128 129 "A resolved reference mix-in." 130 131 def __init__(self, ref): 132 self.ref = ref 133 134 def reference(self): 135 return self.ref 136 137 def references(self): 138 return [self.ref] 139 140 def get_name(self): 141 return self.ref and self.ref.get_name() or None 142 143 def get_origin(self): 144 return self.ref and self.ref.get_origin() or None 145 146 def static(self): 147 return self.ref and self.ref.static() or None 148 149 def final(self): 150 return self.ref and self.ref.final() or None 151 152 def has_kind(self, kinds): 153 return self.ref and self.ref.has_kind(kinds) 154 155 def is_constant_alias(self): 156 return self.ref and self.ref.is_constant_alias() 157 158 class ResolvedNameRef(ResolvedRef, NameRef): 159 160 "A resolved name-based reference." 161 162 def __init__(self, name, ref, expr=None, is_global=False): 163 NameRef.__init__(self, name, expr, is_global) 164 ResolvedRef.__init__(self, ref) 165 166 def __repr__(self): 167 return "ResolvedNameRef(%r, %r, %r, %r)" % (self.name, self.ref, self.expr, self.is_global) 168 169 class ConstantValueRef(ResolvedNameRef): 170 171 "A constant reference representing a single literal value." 172 173 def __init__(self, name, ref, value, number=None): 174 ResolvedNameRef.__init__(self, name, ref) 175 self.value = value 176 self.number = number 177 178 def __repr__(self): 179 return "ConstantValueRef(%r, %r, %r, %r)" % (self.name, self.ref, self.value, self.number) 180 181 class InstanceRef(ResolvedRef, Result): 182 183 "An instance reference." 184 185 def reference(self): 186 return self.ref 187 188 def __repr__(self): 189 return "InstanceRef(%r)" % self.ref 190 191 class LiteralSequenceRef(ResolvedNameRef): 192 193 "A reference representing a sequence of values." 194 195 def __init__(self, name, ref, node, items=None): 196 ResolvedNameRef.__init__(self, name, ref) 197 self.node = node 198 self.items = items 199 200 def __repr__(self): 201 return "LiteralSequenceRef(%r, %r, %r, %r)" % (self.name, self.ref, self.node, self.items) 202 203 class VariableRef(Result): 204 205 "A variable reference." 206 207 def __repr__(self): 208 return "VariableRef()" 209 210 # vim: tabstop=4 expandtab shiftwidth=4