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 get_name(self): 46 return None 47 48 def get_origin(self): 49 return None 50 51 def static(self): 52 return None 53 54 def final(self): 55 return None 56 57 def has_kind(self, kinds): 58 return False 59 60 class AccessRef(Result): 61 62 """ 63 A reference to an attribute access that is generally only returned from a 64 processed access for possible initialiser resolution for assignments. 65 """ 66 67 def __init__(self, original_name, attrnames, number): 68 self.original_name = original_name 69 self.attrnames = attrnames 70 self.number = number 71 72 def __repr__(self): 73 return "AccessRef(%r, %r, %r)" % (self.original_name, self.attrnames, self.number) 74 75 class InvocationRef(Result): 76 77 "An invocation of a name reference." 78 79 def __init__(self, name_ref): 80 self.name_ref = name_ref 81 82 def reference(self): 83 origin = self.name_ref.get_origin() 84 if origin: 85 return Reference("<invoke>", origin) 86 else: 87 return Reference("<var>") 88 89 def __repr__(self): 90 return "InvocationRef(%r)" % self.name_ref 91 92 class NameRef(Result): 93 94 "A reference to a name." 95 96 def __init__(self, name, expr=None, is_global=False): 97 self.name = name 98 self.expr = expr 99 self.is_global = is_global 100 101 def is_name(self): 102 return True 103 104 def is_global_name(self): 105 return self.is_global 106 107 def final(self): 108 return None 109 110 def __repr__(self): 111 return "NameRef(%r, %r, %r)" % (self.name, self.expr, self.is_global) 112 113 class LocalNameRef(NameRef): 114 115 "A reference to a local name." 116 117 def __init__(self, name, number): 118 NameRef.__init__(self, name, is_global=False) 119 self.number = number 120 121 def __repr__(self): 122 return "LocalNameRef(%r, %r)" % (self.name, self.number) 123 124 class ResolvedRef: 125 126 "A resolved reference mix-in." 127 128 def __init__(self, ref): 129 self.ref = ref 130 131 def reference(self): 132 return self.ref 133 134 def references(self): 135 return [self.ref] 136 137 def get_name(self): 138 return self.ref and self.ref.get_name() or None 139 140 def get_origin(self): 141 return self.ref and self.ref.get_origin() or None 142 143 def static(self): 144 return self.ref and self.ref.static() or None 145 146 def final(self): 147 return self.ref and self.ref.final() or None 148 149 def has_kind(self, kinds): 150 return self.ref and self.ref.has_kind(kinds) 151 152 def is_constant_alias(self): 153 return self.ref and self.ref.is_constant_alias() 154 155 class ResolvedNameRef(ResolvedRef, NameRef): 156 157 "A resolved name-based reference." 158 159 def __init__(self, name, ref, expr=None, is_global=False): 160 NameRef.__init__(self, name, expr, is_global) 161 ResolvedRef.__init__(self, ref) 162 163 def __repr__(self): 164 return "ResolvedNameRef(%r, %r, %r, %r)" % (self.name, self.ref, self.expr, self.is_global) 165 166 class ConstantValueRef(ResolvedNameRef): 167 168 "A constant reference representing a single literal value." 169 170 def __init__(self, name, ref, value, number=None): 171 ResolvedNameRef.__init__(self, name, ref) 172 self.value = value 173 self.number = number 174 175 def __repr__(self): 176 return "ConstantValueRef(%r, %r, %r, %r)" % (self.name, self.ref, self.value, self.number) 177 178 class InstanceRef(ResolvedRef, Result): 179 180 "An instance reference." 181 182 def reference(self): 183 return self.ref 184 185 def __repr__(self): 186 return "InstanceRef(%r)" % self.ref 187 188 class LiteralSequenceRef(ResolvedNameRef): 189 190 "A reference representing a sequence of values." 191 192 def __init__(self, name, ref, node, items=None): 193 ResolvedNameRef.__init__(self, name, ref) 194 self.node = node 195 self.items = items 196 197 def __repr__(self): 198 return "LiteralSequenceRef(%r, %r, %r, %r)" % (self.name, self.ref, self.node, self.items) 199 200 class VariableRef(Result): 201 202 "A variable reference." 203 204 def __repr__(self): 205 return "VariableRef()" 206 207 # vim: tabstop=4 expandtab shiftwidth=4