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