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)