def resolveNameRef(self, visitor, callinfo):
# assert False
# visitor.logger.debug('LibFuncMatch.resolveNameRef', self, visitor, callinfo)
callinfo.getOwnerFunc().info.dispatched = True
argcount = len(callinfo.args)
assert argcount == 2
caseblock = callinfo.args[-1]
assert isinstance(caseblock, ast.CaseBlock)
if argcount == 2:
caseblock.matchVar = callinfo.args[0]
for entry in caseblock.entries:
# visitor.logger.debug('match resolve entry', callinfo.caller, caseblock.matchVar, entry.pattern, callinfo.getOwnerFunc())
assert hasattr(entry.pattern,
'name'), ('match resolve entry',
callinfo.caller,
caseblock.matchVar, entry.pattern,
callinfo.getOwnerFunc())
assert hasattr(caseblock.matchVar,
'name'), ('match resolve matchVar',
callinfo.caller,
caseblock.matchVar, entry.pattern,
callinfo.getOwnerFunc())
casevar = ast.CaseVarSpec(
ast.Param(caseblock.matchVar.name,
ast.UserType([entry.pattern.name])))
entry.addSymbol(casevar.variable)
casevar.setOwner(entry)
visitor.visitNewItem(casevar)
def resolveNameRef(self, visitor, callinfo):
# visitor.logger.debug('LibFuncMatch.resolveNameRef', self, visitor, callinfo, callinfo.getOwnerFunc(), callinfo.caller, callinfo.args)
# assert False
callinfo.getOwnerFunc().info.dispatched = True
argcount = len(callinfo.args)
assert argcount in [1, 2]
caseblock = callinfo.args[-1]
assert isinstance(caseblock, ast.CaseBlock)
if argcount == 2:
caseblock.matchVar = callinfo.args[0]
for entry in caseblock.entries:
if entry.pattern:
assert hasattr(entry.pattern,
'name'), ('match resolve entry',
callinfo.caller,
caseblock.matchVar, entry.pattern,
callinfo.getOwnerFunc())
assert hasattr(caseblock.matchVar,
'name'), ('match resolve matchVar',
callinfo.caller,
caseblock.matchVar, entry.pattern,
callinfo.getOwnerFunc())
# casevar = ast.CaseVarSpec(ast.Param(caseblock.matchVar.name, ast.UserType([entry.pattern.name])))
entry.pattern = ast.VarTag(
caseblock.matchVar.name,
ast.UserType([entry.pattern.name]))
# visitor.logger.debug('match resolve entry', callinfo.caller, caseblock.matchVar, entry.pattern, callinfo.getOwnerFunc())
visitor.setupNewItem(entry.pattern, entry, False)
def __init__(self, name):
ast.LibClassBase.__init__(self)
self.name = name
self.constructors = []
self.bases = []
self.spec = ast.FuncSpec([], ast.UserType([self.name]))
self.definitions = []
self.astFieldNames = ['definitions']
def processScript(self, visitor, script):
owner = script.owner
# visitor.logger.debug('MixinScript.processScript', script, owner.bases, script.args)
assert isinstance(owner, ast.ClassDef)
script.mixin_var_type = ast.UserType(getScriptQuialifiedName(script.args[0]))
script.mixin_var = ast.SingleVarDef(script.mixin_var_name, script.mixin_var_type, ast.Call(script.args[0].clone(), script.args[3:], script.namedArgs))
proto = parseFuncProto('%s() => %s' % (script.mixin_propget_name, script.mixin_var_type.fullpath))
script.mixin_propget = ast.FuncDef([], script.mixin_propget_name, proto.spec, ast.StatementBody([ast.Return(ast.Identifier(script.mixin_var_name))]))
script.mixin_class = owner.resolveSymbol(script.mixin_var_type.path)
# visitor.logger.debug('MixinScript.processScript add var', owner, script.owner, script, owner.bases, script.args, script.mixin_var)
owner.definitions.append(script.mixin_var)
script.mixin_var.setOwner(script.owner)
owner.definitions.append(script.mixin_propget)
script.mixin_propget.setOwner(script.owner)
# visitor.logger.debug('MixinScript.processScript add var', owner, script.owner, script, owner.bases, script.args, script.mixin_var, script.mixin_var.owner)
visitor.visitNewItem(script.mixin_var)
visitor.visitNewItem(script.mixin_propget)
self.addMixinFuncs(visitor, script, script.mixin_class, owner)
def resolveName_FuncDef(self, func):
# self.logger.debug('resolveName_FuncDef', func.name, func, func.owner)
if isinstance(func.owner, ast.ExtensionDef):
func.cls = func.owner.cls
func.owner.cls.addSymbol(func)
owner = func.owner
if func.info.type == ast.FuncType.constructor:
# self.logger.debug('resolveName_FuncDef constructor returnType', func.name, func, func.owner)
assert func.spec.returnType is None
func.spec.returnType = ast.UserType([func.cls.name])
self.setupNewItem(func.spec.returnType, func.spec, False)
assert isinstance(owner, ast.ClassDef) or isinstance(owner, ast.CodeUnit) or isinstance(owner, ast.ExtensionDef), 'resolveName_FuncDef owner is invalid: %s %s' % (owner, func)
if func.info.type == ast.FuncType.constructor:
for var in func.owner.vars:
if var.initial:
stmt = ast.Assignment([ast.Identifier(var.name)], '=', [var.initial])
func.body.statements.insert(0, stmt)
# self.logger.debug('resolveName_FuncDef initialize var', func.name, stmt, var, var.initial)
self.setupNewItem(stmt, func.body, False)
func.visitChildren(self)
class GenericArrayClassImpl(GenericClassImpl):
genericParams = [ast.GenericTypeParam('ElementType'), ast.GenericLiteralParam(ast.UserType(['int']))]
def __init__(self, genericArgs):
super(GenericArrayClassImpl, self).__init__(GenericArrayClassImpl.genericParams, genericArgs)
self.addDef(GenericArrayEachFunc(self))
assert isinstance(genericArgs[1].literal, ast.IntLiteral), (genericArgs[1], self)
self.size = genericArgs[1].literal.value
def createElementType(self):
return ast.UserType(['ElementType'])
def evaluateNil(self, visitor):
# assert False
return [visitor.nilValue] * self.size
def eval_get(self, coll, key, defval=None):
# print('GenericArrayClassImpl.eval_get', coll, key, defval)
return coll.get(key, defval)
def eval_set(self, coll, key, item):
# assert False, (self, coll, item)
# print('GenericArrayClassImpl.eval_set', self, coll, key, item)
assert key is not None, (self, coll, key, item)
# assert isinstance(key, str), (self, coll, key, item)
# assert False, (self, coll, key, item)
coll[key] = item
return None
def createElementType(self):
return ast.UserType(['ElementType'])
def createValueType(self):
return ast.UserType(['ValueType'])
def createKeyType(self):
return ast.UserType(['KeyType'])
def resolve_This(self, expr):
# self.logger.debug('resolve_This', expr.owner, expr.getOwnerFunc(), expr.getOwnerClass())
if expr.getType() is None:
expr.setupType(ast.UserType([expr.getOwnerClass().name]), self)
def __init__(self, name, impl, evaluator=None):
LibClass.__init__(self, name)
self.returnType = ast.UserType([self.name])
self.spec = makeFuncSpec(self.returnType, [])
self.evaluator = evaluator
self.impl = impl
def preexpand_CaseClassDef(self, casecls):
cls = ast.ClassDef(casecls.scripts, casecls.name, casecls.genericParams, [ast.UserType([casecls.owner.name])], casecls.fields, casecls.definitions, ast.ClassType.normal)
assert casecls.owner.owner
clsOwner = casecls.owner.owner.getOwnerFullContext()
clsOwner.definitions.append(cls)
self.setupNewItem(cls, clsOwner, False)
