1 #!/usr/bin/env python 2 3 """ 4 Result abstractions. 5 6 Copyright (C) 2016 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 def get_origin(self): 33 return None 34 35 class AccessRef(Result): 36 37 """ 38 A reference to an attribute access that is generally only returned from a 39 processed access for possible initialiser resolution for assignments. 40 """ 41 42 def __init__(self, original_name, attrnames, number): 43 self.original_name = original_name 44 self.attrnames = attrnames 45 self.number = number 46 47 def reference(self): 48 return None 49 50 def __repr__(self): 51 return "AccessRef(%r, %r, %r)" % (self.original_name, self.attrnames, self.number) 52 53 class InvocationRef(Result): 54 55 "An invocation of a name reference." 56 57 def __init__(self, name_ref): 58 self.name_ref = name_ref 59 60 def reference(self): 61 origin = self.name_ref.get_origin() 62 if origin: 63 return Reference("<invoke>", origin) 64 else: 65 return Reference("<var>") 66 67 def __repr__(self): 68 return "InvocationRef(%r)" % self.name_ref 69 70 class NameRef(Result): 71 72 "A reference to a name." 73 74 def __init__(self, name, expr=None): 75 self.name = name 76 self.expr = expr 77 78 def is_name(self): 79 return True 80 81 def reference(self): 82 return None 83 84 def final(self): 85 return None 86 87 def __repr__(self): 88 return "NameRef(%r, %r)" % (self.name, self.expr) 89 90 class LocalNameRef(NameRef): 91 92 "A reference to a local name." 93 94 def __init__(self, name, number): 95 NameRef.__init__(self, name) 96 self.number = number 97 98 def __repr__(self): 99 return "LocalNameRef(%r, %r)" % (self.name, self.number) 100 101 class ResolvedNameRef(NameRef): 102 103 "A resolved name-based reference." 104 105 def __init__(self, name, ref, expr=None): 106 NameRef.__init__(self, name, expr) 107 self.ref = ref 108 109 def reference(self): 110 return self.ref 111 112 def get_name(self): 113 return self.ref and self.ref.get_name() or None 114 115 def get_origin(self): 116 return self.ref and self.ref.get_origin() or None 117 118 def static(self): 119 return self.ref and self.ref.static() or None 120 121 def final(self): 122 return self.ref and self.ref.final() or None 123 124 def has_kind(self, kinds): 125 return self.ref and self.ref.has_kind(kinds) 126 127 def __repr__(self): 128 return "ResolvedNameRef(%r, %r, %r)" % (self.name, self.ref, self.expr) 129 130 class ConstantValueRef(ResolvedNameRef): 131 132 "A constant reference representing a single literal value." 133 134 def __init__(self, name, ref, value, number=None): 135 ResolvedNameRef.__init__(self, name, ref) 136 self.value = value 137 self.number = number 138 139 def __repr__(self): 140 return "ConstantValueRef(%r, %r, %r, %r)" % (self.name, self.ref, self.value, self.number) 141 142 class InstanceRef(Result): 143 144 "An instance reference." 145 146 def __init__(self, ref): 147 self.ref = ref 148 149 def reference(self): 150 return self.ref 151 152 def __repr__(self): 153 return "InstanceRef(%r)" % self.ref 154 155 class LiteralSequenceRef(ResolvedNameRef): 156 157 "A reference representing a sequence of values." 158 159 def __init__(self, name, ref, node, items=None): 160 ResolvedNameRef.__init__(self, name, ref) 161 self.node = node 162 self.items = items 163 164 def __repr__(self): 165 return "LiteralSequenceRef(%r, %r, %r, %r)" % (self.name, self.ref, self.node, self.items) 166 167 # vim: tabstop=4 expandtab shiftwidth=4