def resolve(self, outer):
from pysonarsq.java.Binding import Binding
from pysonarsq.java.types.FunType import FunType
from pysonarsq.java.Analyzer import Analyzer
from pysonarsq.java.Scope import Scope
self.resolveList(self.decoratorList, outer)
# XXX: not handling functional transformations yet
fun = FunType(self, outer.getForwarding())
fun.getTable().setParent(outer)
fun.getTable().setPath(outer.extendPath(self.name.id))
fun.setDefaultTypes(self.resolveAndConstructList(self.defaults, outer))
Analyzer.self.addUncalled(fun)
funkind = Binding.Kind()
if outer.getScopeType() == Scope.ScopeType.CLASS:
if "__init__" == self.name.id:
funkind = Binding.Kind.CONSTRUCTOR
else:
funkind = Binding.Kind.METHOD
else:
funkind = Binding.Kind.FUNCTION
outType = outer.getType()
if outType is not None and outType.isClassType():
fun.setCls(outType.asClassType())
Binder.bind(outer, self.name, fun, funkind)
return Analyzer.self.builtins.Cont
def bindParams(cls, call, funcTable, args, fvarargs, fkwargs, aTypes,
dTypes, kwTypes, kwargsType, starargsType):
from pysonarsq.java.Analyzer import Analyzer
from pysonarsq.java.Binder import Binder
fromType = TupleType()
aSize = 0 if aTypes is None else len(aTypes)
dSize = 0 if dTypes is None else len(dTypes)
nPositional = len(args) - dSize
if starargsType is not None and starargsType.isListType():
starargsType = starargsType.asListType().toTupleType()
j = 0
for i, arg in enumerate(range(len(args))):
arg = args[i]
if i < aSize:
aType = aTypes[i]
elif i - nPositional >= 0 and i - nPositional < dSize:
aType = dTypes[i - nPositional]
else:
if kwTypes is not None and args[i].isName() and args[i].asName(
).id in kwTypes:
aType = kwTypes[args[i].asName().id]
del kwTypes[args[i].asName().id]
elif starargsType is not None and starargsType.isTupleType(
) and j < len(starargsType.asTupleType().getElementTypes()):
aType = starargsType.asTupleType().get(j)
j += 1
else:
aType = Analyzer.self.builtins.unknown
if call is not None:
Analyzer.self.putProblem(
args[i], "unable to bind argument:" + str(args[i]))
Binder.bind(funcTable, arg, aType, Binding.Kind.PARAMETER)
fromType.add(aType)
if fkwargs is not None:
if kwTypes is not None and len(kwTypes):
kwValType = UnionType.newUnion(kwTypes.values())
Binder.bind(
funcTable, fkwargs,
DictType(Analyzer.self.builtins.BaseStr, kwValType),
Binding.Kind.PARAMETER)
else:
Binder.bind(funcTable, fkwargs, Analyzer.self.builtins.unknown,
Binding.Kind.PARAMETER)
if fvarargs is not None:
if len(aTypes) > len(args):
starType = TupleType(aTypes[len(args):len(aTypes)])
Binder.bind(funcTable, fvarargs, starType,
Binding.Kind.PARAMETER)
else:
Binder.bind(funcTable, fvarargs,
Analyzer.self.builtins.unknown,
Binding.Kind.PARAMETER)
return fromType
def resolve(self, s):
from pysonarsq.java.Binder import Binder
from pysonarsq.java.Binding import Binding
from pysonarsq.java.Analyzer import Analyzer
classType = ClassType(self.getName().id, s)
baseTypes = ArrayList()
for base in self.bases:
baseType = self.resolveExpr(base, s);
if baseType.isClassType():
classType.addSuper(baseType)
elif baseType.isUnionType():
for b in baseType.asUnionType().getTypes():
classType.addSuper(b)
break
else:
Analyzer.self.putProblem(base, str(base) + " is not a class")
baseTypes.append(baseType)
# XXX: Not sure if we should add "bases", "name" and "dict" here. They
# must be added _somewhere_ but I'm just not sure if it should be HERE.
builtins = Analyzer.self.builtins
self.addSpecialAttribute(classType.getTable(), "__bases__", TupleType(baseTypes))
self.addSpecialAttribute(classType.getTable(), "__name__", builtins.BaseStr)
self.addSpecialAttribute(classType.getTable(), "__dict__", DictType(builtins.BaseStr, Analyzer.self.builtins.unknown))
self.addSpecialAttribute(classType.getTable(), "__module__", builtins.BaseStr)
self.addSpecialAttribute(classType.getTable(), "__doc__", builtins.BaseStr)
# Bind ClassType to name here before resolving the body because the
# methods need this type as self.
Binder.bind(s, self.name, classType, Binding.Kind.CLASS)
self.resolveExpr(self.body, classType.getTable())
return Analyzer.self.builtins.Cont
def resolve(self, s):
from pysonarsq.java.Analyzer import Analyzer
if self.rvalue is None:
Analyzer.self.putProblem(self, "missing RHS of assignment")
else:
valueType = self.resolveExpr(self.rvalue, s)
for t in self.targets:
Binder.bind(s, t, valueType)
return Analyzer.self.builtins.Cont
def resolve(self, s):
from pysonarsq.java.Analyzer import Analyzer
if self.rvalue is None:
Analyzer.self.putProblem(self, "missing RHS of assignment")
else:
valueType = self.resolveExpr(self.rvalue, s);
for t in self.targets:
Binder.bind(s, t, valueType)
return Analyzer.self.builtins.Cont
def resolve(self, s):
from pysonarsq.java.Analyzer import Analyzer
Binder.bindIter(s, self.target, self.iter, Binding.Kind.SCOPE)
ret = None
if self.body is None:
ret = Analyzer.self.builtins.unknown
else:
ret = self.resolveExpr(self.body, s)
if self.orelse is not None:
ret = UnionType.union(ret, self.resolveExpr(self.orelse, s))
return ret
def resolve(self, s):
from pysonarsq.java.Analyzer import Analyzer
typeval = Analyzer.self.builtins.unknown
if self.exceptionType is not None:
typeval = self.resolveExpr(self.exceptionType, s)
if self.name is not None:
Binder.bind(s, self.name, typeval)
if self.body is not None:
return self.resolveExpr(self.body, s)
else:
return Analyzer.self.builtins.unknown
def resolve(self, s):
from pysonarsq.java.Analyzer import Analyzer
typeval = Analyzer.self.builtins.unknown
if self.exceptionType is not None:
typeval = self.resolveExpr(self.exceptionType, s)
if self.name is not None:
Binder.bind(s, self.name, typeval)
if self.body is not None:
return self.resolveExpr(self.body, s)
else:
return Analyzer.self.builtins.unknown
def resolve(self, outer):
from pysonarsq.java.Analyzer import Analyzer
self.defaultTypes = self.resolveAndConstructList(self.defaults, outer)
cl = FunType(self, outer.getForwarding())
cl.getTable().setParent(outer)
cl.getTable().setPath(outer.extendPath(self.getName().id))
Binder.bind(outer, self.getName(), cl, Binding.Kind.FUNCTION)
cl.setDefaultTypes(self.resolveAndConstructList(self.defaults, outer))
Analyzer.self.addUncalled(cl)
return cl
def resolve(self, s):
from pysonarsq.java.Analyzer import Analyzer
Binder.bindIter(s, self.target, self.iter, Binding.Kind.SCOPE)
ret = None
if self.body is None:
ret = Analyzer.self.builtins.unknown
else:
ret = self.resolveExpr(self.body, s)
if self.orelse is not None:
ret = UnionType.union(ret, self.resolveExpr(self.orelse, s))
return ret
def bindParams(cls, call, funcTable, args, fvarargs, fkwargs, aTypes, dTypes, kwTypes, kwargsType, starargsType):
from pysonarsq.java.Analyzer import Analyzer
from pysonarsq.java.Binder import Binder
fromType = TupleType()
aSize = 0 if aTypes is None else len(aTypes)
dSize = 0 if dTypes is None else len(dTypes)
nPositional = len(args) - dSize
if starargsType is not None and starargsType.isListType():
starargsType = starargsType.asListType().toTupleType()
j = 0
for i, arg in enumerate(range(len(args))):
arg = args[i]
if i < aSize:
aType = aTypes[i]
elif i - nPositional >= 0 and i - nPositional < dSize:
aType = dTypes[i - nPositional]
else:
if kwTypes is not None and args[i].isName() and args[i].asName().id in kwTypes:
aType = kwTypes[args[i].asName().id]
del kwTypes[args[i].asName().id]
elif starargsType is not None and starargsType.isTupleType() and j < len(starargsType.asTupleType().getElementTypes()):
aType = starargsType.asTupleType().get(j)
j += 1
else:
aType = Analyzer.self.builtins.unknown
if call is not None:
Analyzer.self.putProblem(args[i], "unable to bind argument:" + str(args[i]))
Binder.bind(funcTable, arg, aType, Binding.Kind.PARAMETER)
fromType.add(aType)
if fkwargs is not None:
if kwTypes is not None and len(kwTypes):
kwValType = UnionType.newUnion(kwTypes.values());
Binder.bind(funcTable, fkwargs, DictType(Analyzer.self.builtins.BaseStr, kwValType), Binding.Kind.PARAMETER)
else:
Binder.bind(funcTable, fkwargs, Analyzer.self.builtins.unknown, Binding.Kind.PARAMETER)
if fvarargs is not None:
if len(aTypes) > len(args):
starType = TupleType(aTypes[len(args) : len(aTypes)]);
Binder.bind(funcTable, fvarargs, starType, Binding.Kind.PARAMETER)
else:
Binder.bind(funcTable, fvarargs, Analyzer.self.builtins.unknown, Binding.Kind.PARAMETER)
return fromType
def resolve(self, s):
for item in self.items:
if item.optional_vars is not None:
val = self.resolveExpr(item.context_expr, s);
Binder.bind(s, item.optional_vars, val)
return self.resolveExpr(self.body, s)
def resolve(self, s):
for item in self.items:
if item.optional_vars is not None:
val = self.resolveExpr(item.context_expr, s)
Binder.bind(s, item.optional_vars, val)
return self.resolveExpr(self.body, s)
def resolve(self, s):
Binder.bindIter(s, self.target, self.iter, Binding.Kind.SCOPE)
self.resolveList(self.ifs, s)
return self.resolveExpr(self.target, s)