#Edge guards.

def f():
    x = None

    if x is None:
        x = 7
    use(x)

    x = unknown() if cond else None

    if x is not None:
        x = 7
    use(x)

    x = None

    if x is None:
        x = None
    use(x)

    x = None

    if not x:
        x = 7
    use(x)

    x = unknown() if cond else None

    if x:
        x = 7
    use(x)

    x = None

    if not x:
        x = None
    use(x)

    i = 0
    if i == 0:
        i = 1.0
    use(i)

    i = 0
    if i != 0:
        i = 1.0
    use(i)

    i = 0
    if i == 0:
        i = 0
    use(i)

    i = 0
    if not i:
        i = 1.0
    use(i)

    i = unknown() if cond else 0
    if i:
        i = 1.0
    use(i)

    i = 0
    if not i:
        i = 0
    use(i)


    i = 7
    if i == 7:
        i = 1.0
    use(i)

    i = 7
    if i != 7:
        i = 1.0
    use(i)

    i = 7
    if i == 7:
        i = 7
    use(i)

    b = True

    if b:
        b = 7
    use(b)

    b = unknown() if cond else True

    if not b:
        b = 7
    use(b)


    b = unknown() if cond else False

    if b:
        b = 7
    use(b)

    b = False

    if not b:
        b = 7
    use(b)

    t = type
    if t is object:
        t = float
    use(t)

    t = type
    if t is not object:
        t = object
    use(t)

    u = unknown_thing()

    if u is None:
        u = 7
    use(u)

    u = unknown_thing()

    if u is not None:
        u = 7
    use(u)

    u = unknown_thing()

    if u:
        u = 7
    use(u)

    u = unknown_thing()

    if not u:
        u = 7
    use(u)

    K = unknown_thing()

    u = unknown_thing()

    if u is K:
        u = 7
    use(u)

    u = unknown_thing()

    if u is not K:
        u = 7
    use(u)

#String and float consts.

    s = "not this"
    if s == "not this":
        s = 1.0
    use(s)

    f = 0.7
    if f == 0.7:
        f = 0
    use(f)

#Sentinel guards
SENTINEL = object()
def g(x = SENTINEL):
    if x is SENTINEL:
        x = 0
    use(x)

def h(x = SENTINEL):
    if x == SENTINEL:
        x = 0
    use(x)

def j(x = SENTINEL):
    if x is not SENTINEL:
        x = 0
    use(x)

#ODASA-4056
def format_string(s, formatter='minimal'):
    """Format the given string using the given formatter."""
    if not callable(formatter):
        formatter = get_formatter_for_name(formatter)
    use(formatter)

def guard_callable(s, f=j):
    """Format the given string using the given formatter."""
    if callable(f):
        f=0
    use(f)

class C1(object):pass
class C2(C1):pass

def guard_subclass(s = C2):
    if issubclass(s, C1):
        s = type
    use(s)

def guard_subclass2(s = C2):
    if not issubclass(s, C1):
        use(s)
        s = type
    else:
        use(s)
    use(s)

def instance_guard(s, f=1.0):
    if isinstance(s, float):
        s = 0
    use(s)


#ODASA-4056
def format_string(s, formatter='minimal'):
    """Format the given string using the given formatter."""
    if not callable(formatter):
        formatter = get_formatter_for_name(formatter)
    use(formatter)

func_type = type(j)
def guard_callable(s, f=j):
    if isinstance(f, func_type):
        f=0
    use(f)


#Attribute points-to
class C(object):

    def __init__(self):
        self._init()
        self.x = 1

    def _init(self):
        self.y = 2
        self._init2()

    def _init2(self):
        self.z = 3

    def method(self):
        use(self.x)
        if isinstance(self.y, int):
            use(self.y)
        if not isinstance(self.z, int):
            use(self.z)

#Guarded None in nested function
def f(x=None):
    def inner(arg):
        if x:
            use(x)



#Guards on whole scope...
class D(object):

    def __init__(self, x = None):
        if x is None:
            x = 1
        use(x)
        self.x = x

    def f(self):
        use(self.x)

#Biased splitting & pruning
def f(cond):
    if cond:
        y = None
        x = False
    else:
        y = something()
        x = some_condition()
    use(y) # y can be None here
    if x:
        use(y) # Should not infer that y is None here

#Splittings with boolean expressions:
def split_bool1(x=None,y=None):
    if x and y:
        raise
    if not (x or y):
        raise
    if x:
        use(y)
    else:
        use(y)
    if y:
        use(x)
    else:
        use(x)

def split_bool2(x,y=None,z=7):
    if x and not y or x and use(y):
        pass
    if x and not z or x and use(z):
        pass

def split_bool3(a=None, b=None):
    if a or b:
        if a:
            use(b)
        else:
            use(b) # Should not infer b to be None.

#Guard on instance attribute
class E(object):

    def __init__(self):
        self.y = None if rand() else 4

    x = None if rand() else 3

    def a(self):
        e = E()
        #Do not mutate
        if e.x:
            use(e.x)
        if e.y:
            use(e.y)

    def b(self):
        possibly_mutate(self)
        if self.x:
            use(self.x)
        if self.y:
            use(self.y)

def k():
    e = E()
    possibly_mutate(e)
    if e.x:
        use(e.x)
    if e.y:
        use(e.y)


#Global assignment in local scope
g1 = None

def assign_global():
    global g1
    if not g1:
        g1 = 7.0
    use(g1) # Cannot be None

#Assignment in local scope, but called from module level

g2 = None

def init():
    global g2
    if not g2:
        g2 = 2.0

init()
use(g2) # Cannot be None

#Global set in init method
g3 = None

class Ugly(object):

    def __init__(self):
        global g3
        if not g3:
            g3 = True

    def meth(self):
        use(g3)  # Cannot be None

g4 = None

def get_g4():
    if not g4:
        set_g4()
    use(g4) # Cannot be None

def set_g4():
    set_g4_indirect()

def set_g4_indirect():
    global g4
    g4 = 7

#Assertions
def f(cond):
    x = None if cond else thing()
    assert x
    use(x)

def f(cond, x = 1):
    if cond:
        x = 1.0
    assert isinstance(x, int)
    use(x)

#ODASA-5018
def f(x,y=None, z=0):
    if (x and y) or (y and not z):
        #y cannot be None here.
        use(y)

class C(object):

    def __init__(self, x=None):
        self.x = x
        use(self.x)

    def meth(self):
        if self.x is not None:
            use(self.x)
            return lambda : use(self.x)
        else:
            use(self.x)
            return lambda : use(self.x)


def test_on_unknown_attr():
    e = E()
    y = 1
    if e.attr:
        use(y)