def test_is_basetype(self):
true = self.assertTrue
true( int_t.is_base() )
true( float_t.is_base() )
true( str_t.is_base() )
true( unicode_t.is_base() )
true( bool_t.is_base() )
true( unit_t.is_base() )
equal = self.assertEqual
equal( PType.int(), int_t )
equal( PType.float(), float_t )
equal( PType.string(), str_t )
equal( PType.unicode(), unicode_t )
equal( PType.bool(), bool_t )
equal( PType.unit(), unit_t )
all(equal(PType.from_str(k), v) for (k,v) in base_ts.iteritems())
def valid_int_slice(l, u, s, env):
"""
Determine if three AST expr nodes representing the parameters to a simple
slice are valid integers (or Nones) under type environment `env`.
`l`: AST expr node representing lower bound of slice.
`u`: AST expr node representing upper bound of slice.
`s`: AST expr node representing step of slice.
`n`: (int) length of the collection being sliced.
"""
# These are imported here because we don't want to pollute the entire util
# module with potential circular references. In theory, util.py functions
# shouldn't need to refer to checking or inferring, but this is a function
# that happens to be shared between typecheck.py and infer.py.
from check import check_expr
from ptype import PType
int_t = PType.int()
return ((l is None or check_expr(l, int_t, env))
and (u is None or check_expr(u, int_t, env))
and (s is None or node_is_None(s) or check_expr(s, int_t, env)))
import sys
import unittest
from lepl import sexpr_to_tree
# Include src in the Python search path
sys.path.insert(0, '../src')
from ptype import (PType, TypeSpecParser, better_sexpr_to_tree, Lst, Stt, Tup,
Mpp, Arr)
int_t = PType.int()
float_t = PType.float()
str_t = PType.string()
unicode_t = PType.unicode()
bool_t = PType.bool()
unit_t = PType.unit()
base_ts = {"int": int_t, "float": float_t, "str": str_t, "unicode": unicode_t,
"bool": bool_t, "unit": unit_t}
class PTypeTests(unittest.TestCase):
def test_is_basetype(self):
true = self.assertTrue
true( int_t.is_base() )
true( float_t.is_base() )
true( str_t.is_base() )
true( unicode_t.is_base() )
true( bool_t.is_base() )
true( unit_t.is_base() )
import ast
import logging
from util import cname, slice_range, node_is_int, valid_int_slice
from errors import TypeUnspecifiedError
from ptype import PType
from settings import DEBUG_INFER
# Need to use this form to resolve circular import.
import check
int_t = PType.int()
float_t = PType.float()
bool_t = PType.bool()
str_t = PType.string()
unicode_t = PType.unicode()
unit_t = PType.unit()
log = None
def i_debug(s, cond=True):
log.debug(s, DEBUG_INFER and cond)
def call_function(fun_name, *args, **kwargs):
return globals()[fun_name](*args, **kwargs)
def env_get(env, var_id):
"""
