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