def test():
text = """
class A {
a : String ;
} ;
class Point inherits A {
f ( a : AUTO_TYPE , b : AUTO_TYPE ) : AUTO_TYPE {
if ( a = 1 ) then b else
g ( a + 1 , b / 2 )
fi
} ;
g ( a : AUTO_TYPE , b : AUTO_TYPE ) : AUTO_TYPE {
if ( b = 1 ) then a else
f ( a / 2 , b + 1 )
fi
} ;
} ;
"""
ast = run_pipeline(text)
errors = []
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
__ = checker.visit(ast, None)
tset_builder = TSetBuilder(context, errors)
tset = tset_builder.visit(ast, None)
tset_reducer = TSetReducer(context, errors)
reduced_set = tset_reducer.visit(ast, tset)
print("Errors:", errors)
print("Context:")
print(context)
print(reduced_set)
assert errors == ["A class Main with a method main most be provided"]
def test():
text = """
class A {
a : String ;
} ;
class Point inherits A {
ackermann ( m : AUTO_TYPE , n : AUTO_TYPE ) : AUTO_TYPE {
if m < 0 then 1 else
if n < 0 then ackermann ( m - 1 , 1 ) else
ackermann ( m - 1 , ackermann ( m , n - 1 ) )
fi
fi
} ;
} ;
"""
ast = run_pipeline(text)
errors = []
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
__ = checker.visit(ast, None)
tset_builder = TSetBuilder(context, errors)
tset = tset_builder.visit(ast, None)
tset_reducer = TSetReducer(context, errors)
reduced_set = tset_reducer.visit(ast, tset)
print("Errors:", errors)
print("Context:")
print(context)
print(reduced_set)
assert errors == ["A class Main with a method main most be provided"]
def test():
text = """
class Main inherits IO {
main(): IO {
let vector: AUTO_TYPE <- (new Vector2).init(0, 0) in
vector.print_vector()
};
};
class Vector2 {
x: AUTO_TYPE;
y: AUTO_TYPE;
init(x_: AUTO_TYPE, y_: AUTO_TYPE): AUTO_TYPE { {
x <- x_;
y <- y_;
self;
} };
get_x(): AUTO_TYPE {
x
};
get_y(): AUTO_TYPE {
y
};
add(v: Vector2): AUTO_TYPE {
(new Vector2).init(x + v.get_x(), y + v.get_y())
};
print_vector(): AUTO_TYPE {
let io: IO <- new IO in {
io.out_string(" ( ");
io.out_int(get_x());
io.out_string("; ");
io.out_int(get_y());
io.out_string(" ) ");
}
};
clone_vector(): AUTO_TYPE {
(new Vector2).init(x, y)
};
};
"""
ast = run_pipeline(text)
errors = []
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
checker.visit(ast, None)
print(errors)
if errors != []:
print(errors)
assert False
tset_builder = TSetBuilder(context, errors)
tset = tset_builder.visit(ast, None)
tset_reducer = TSetReducer(context, errors)
reduced_set = tset_reducer.visit(ast, tset)
tset_merger = TSetMerger(context, errors)
tset_merger.visit(ast, reduced_set)
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
checker.visit(ast, None)
formatter = FormatVisitor()
tree = formatter.visit(ast)
print("Errors:", errors)
print("Context:")
print(context)
print(reduced_set)
print(tree)
assert errors == []
def test():
text = """
class Main {
main(a : AUTO_TYPE) : AUTO_TYPE {
let x : AUTO_TYPE <- 3 in
case x of
y : IO => y.out_string(a);
esac
};
};
"""
ast = run_pipeline(text)
errors = []
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
checker.visit(ast, None)
if errors != [
'"main" method in class Main does not receive any parameters',
]:
print(errors)
assert False
tset_builder = TSetBuilder(context, errors)
tset = tset_builder.visit(ast, None)
tset_reducer = TSetReducer(context, errors)
reduced_set = tset_reducer.visit(ast, tset)
tset_merger = TSetMerger(context, errors)
tset_merger.visit(ast, reduced_set)
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
checker.visit(ast, None)
formatter = FormatVisitor()
tree = formatter.visit(ast)
print("Errors:", errors)
print("Context:")
print(context)
print(reduced_set)
print(tree)
assert errors == [
'"main" method in class Main does not receive any parameters',
'"main" method in class Main does not receive any parameters',
]
def test():
text = """
class A {
a : String ;
b : AUTO_TYPE ;
c : AUTO_TYPE <- 0 ;
d : Object <- while c loop c + 1 pool ;
j : AUTO_TYPE ;
l : AUTO_TYPE ;
fact ( n : AUTO_TYPE ) : AUTO_TYPE { if n < 0 then 1 else n + fact ( n - 1 ) fi } ;
step ( p : AUTO_TYPE ) : AUTO_TYPE {
b <-
{
p + 5 ;
j <- p ;
p <- false ;
isvoid d ;
l @ Point . main ( ) ;
}
} ;
} ;
class Point inherits A {
h : AUTO_TYPE <- "debe ser tipo string" ;
k : AUTO_TYPE ;
main ( ) : AUTO_TYPE {
let i : AUTO_TYPE <- new A in {
isvoid i ; (*Puede lanzar error semantico*)
}
} ;
ackermann ( m : AUTO_TYPE , n : AUTO_TYPE ) : AUTO_TYPE {
if m < 0 then 1 else
if n < 0 then ackermann ( m - 1 , 1 ) else
ackermann ( m - 1 , ackermann ( m , n - 1 ) )
fi
fi
} ;
} ;
"""
ast = run_pipeline(text)
errors = []
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
__ = checker.visit(ast, None)
tset_builder = TSetBuilder(context, errors)
tset = tset_builder.visit(ast, None)
tset_reducer = TSetReducer(context, errors)
reduced_set = tset_reducer.visit(ast, tset)
print("Errors:", errors)
print("Context:")
print(context)
print(reduced_set)
assert errors == ["A class Main with a method main most be provided"]
def test():
text = """
class Main {
main (): Object {
0
};
};
class Point {
x: AUTO_TYPE;
y: AUTO_TYPE;
init(x0: Int, y0: Int): AUTO_TYPE {{
x <- x0;
y <- y0;
self;
}};
};
"""
ast = run_pipeline(text)
errors = []
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
checker.visit(ast, None)
print(errors)
if errors != []:
print(errors)
assert False
tset_builder = TSetBuilder(context, errors)
tset = tset_builder.visit(ast, None)
tset_reducer = TSetReducer(context, errors)
reduced_set = tset_reducer.visit(ast, tset)
tset_merger = TSetMerger(context, errors)
tset_merger.visit(ast, reduced_set)
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
checker.visit(ast, None)
formatter = FormatVisitor()
tree = formatter.visit(ast)
print("Errors:", errors)
print("Context:")
print(context)
print(reduced_set)
print(tree)
assert errors == []
def test():
text = """
class Main {
main (): Object {
0
};
};
class Ackermann {
ackermann(m: AUTO_TYPE, n: AUTO_TYPE): AUTO_TYPE {
if m = 0 then n + 1 else
if n = 0 then ackermann(m - 1, 1) else
ackermann(m - 1, ackermann(m, n - 1))
fi
fi
};
};
"""
ast = run_pipeline(text)
errors = []
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
checker.visit(ast, None)
print(errors)
if errors != []:
print(errors)
assert False
tset_builder = TSetBuilder(context, errors)
tset = tset_builder.visit(ast, None)
tset_reducer = TSetReducer(context, errors)
reduced_set = tset_reducer.visit(ast, tset)
tset_merger = TSetMerger(context, errors)
tset_merger.visit(ast, reduced_set)
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
checker.visit(ast, None)
formatter = FormatVisitor()
tree = formatter.visit(ast)
print("Errors:", errors)
print("Context:")
print(context)
print(reduced_set)
print(tree)
assert errors == []
def test():
text = """
class Main {
main (): Object {
0
};
f (a: AUTO_TYPE, b: AUTO_TYPE, c: AUTO_TYPE, d: AUTO_TYPE): AUTO_TYPE {
{
a <- b;
b <- c;
c <- d;
d <- a;
d + 1;
a;
}
};
};
"""
ast = run_pipeline(text)
errors = []
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
checker.visit(ast, None)
print(errors)
if errors != []:
print(errors)
assert False
tset_builder = TSetBuilder(context, errors)
tset = tset_builder.visit(ast, None)
tset_reducer = TSetReducer(context, errors)
reduced_set = tset_reducer.visit(ast, tset)
tset_merger = TSetMerger(context, errors)
tset_merger.visit(ast, reduced_set)
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
checker.visit(ast, None)
formatter = FormatVisitor()
tree = formatter.visit(ast)
print("Errors:", errors)
print("Context:")
print(context)
print(reduced_set)
print(tree)
assert errors == []
def test():
text = """
(* This program prints the first 10 numbers of fibonacci *)
class Main {
main(): Object {
let total: AUTO_TYPE <- 10,
i: AUTO_TYPE <- 1 ,
io: AUTO_TYPE <- new IO in
while i <= total loop {
io.out_int(fibonacci(i));
io.out_string("n");
i <- i + 1;
}
pool
};
fibonacci (n: AUTO_TYPE): AUTO_TYPE {
if n <= 2 then 1 else fibonacci(n - 1) + fibonacci(n - 2) fi
};
}; """
ast = run_pipeline(text)
errors = []
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
checker.visit(ast, None)
print(errors)
if errors != []:
print(errors)
assert False
tset_builder = TSetBuilder(context, errors)
tset = tset_builder.visit(ast, None)
tset_reducer = TSetReducer(context, errors)
reduced_set = tset_reducer.visit(ast, tset)
tset_merger = TSetMerger(context, errors)
tset_merger.visit(ast, reduced_set)
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
checker.visit(ast, None)
formatter = FormatVisitor()
tree = formatter.visit(ast)
print("Errors:", errors)
print("Context:")
print(context)
print(reduced_set)
print(tree)
assert errors == []
def test():
text = """
class Main {
a : AUTO_TYPE<- "Hola";
main ( ) : Int { {
case {let i: AUTO_TYPE <- 12 in {let i: AUTO_TYPE <- "Hola" in {"Hi";
case 12 of
x : Int => x;
y : AUTO_TYPE => y;
z: String => let i : AUTO_TYPE in {
i<- case self of
x: Int => 12;
x: AUTO_TYPE => if 12<12 then x else "Hola" fi ;
esac
;};
esac
;};};} of
x : Int => 12;
y : AUTO_TYPE => let i: AUTO_TYPE <- y in y ;
esac ;
a.length();} } ;
} ;
"""
ast = run_pipeline(text)
errors = []
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
checker.visit(ast, None)
# print(errors)
# if errors != []:
# print(errors)
# assert False
tset_builder = TSetBuilder(context, errors)
tset = tset_builder.visit(ast, None)
tset_reducer = TSetReducer(context, errors)
reduced_set = tset_reducer.visit(ast, tset)
tset_merger = TSetMerger(context, errors)
tset_merger.visit(ast, reduced_set)
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
checker.visit(ast, None)
formatter = FormatVisitor()
tree = formatter.visit(ast)
# print("Errors:", errors)
# print("Context:")
# print(context)
# print(reduced_set)
# print(tree)
final_tree = """__ProgramNode [<class> ... <class>]__ClassDeclarationNode: class Main { <feature> ... <feature> }__AttrDeclarationNode: a : String <- <exp>__ StringNode: Hola__FuncDeclarationNode: main() : Int { <body> }__BlockNode: {<exp>; ... <exp>;}__CaseNode: case <expr> of <case_block> esac__BlockNode: {<exp>; ... <exp>;}__LetNode: let <identif-list> in <expr>__VarDeclarationNode: i : Int <- <expr>__ ConstantNumNode: 12__BlockNode: {<exp>; ... <exp>;}__LetNode: let <identif-list> in <expr>__VarDeclarationNode: i : String <- <expr>__ StringNode: Hola__BlockNode: {<exp>; ... <exp>;}__ StringNode: Hi__CaseNode: case <expr> of <case_block> esac__ ConstantNumNode: 12__CaseItemNode: x : Int => <exp>;__ VariableNode: x__CaseItemNode: y : Object => <exp>;__ VariableNode: y__CaseItemNode: z : String => <exp>;__LetNode: let <identif-list> in <expr>__VarDeclarationNode: i : Object <- <expr>__NONE__BlockNode: {<exp>; ... <exp>;}__AssignNode: i <- <expr>__CaseNode: case <expr> of <case_block> esac__ VariableNode: self__CaseItemNode: x : Int => <exp>;__ ConstantNumNode: 12__CaseItemNode: x : Object => <exp>;__IfNode: if <expr> then <expr> else <exp> fi__<expr> LessNode <expr>__ ConstantNumNode: 12__ ConstantNumNode: 12__ VariableNode: x__ StringNode: Hola__CaseItemNode: x : Int => <exp>;__ ConstantNumNode: 12__CaseItemNode: y : Object => <exp>;__LetNode: let <identif-list> in <expr>__VarDeclarationNode: i : Object <- <expr>__ VariableNode: y__ VariableNode: y__CallNode: <obj>.length(<expr>, ..., <expr>)__ VariableNode: a"""
tree = tree.replace("\t", "")
tree = tree.replace("\n", "")
tree = tree.replace("\\", "")
assert tree == final_tree
assert errors == []
def test():
text = """
class Main inherits IO {
main() : AUTO_TYPE {
let x : AUTO_TYPE <- 3 + (let y: AUTO_TYPE <- 8 in y ) in
case x of
y: Int => out_string("ok");
esac
};
};
"""
ast = run_pipeline(text)
errors = []
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
checker.visit(ast, None)
print(errors)
if errors != []:
print(errors)
assert False
tset_builder = TSetBuilder(context, errors)
tset = tset_builder.visit(ast, None)
tset_reducer = TSetReducer(context, errors)
reduced_set = tset_reducer.visit(ast, tset)
tset_merger = TSetMerger(context, errors)
tset_merger.visit(ast, reduced_set)
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
checker.visit(ast, None)
formatter = FormatVisitor()
tree = formatter.visit(ast)
print("Errors:", errors)
print("Context:")
print(context)
print(reduced_set)
print(tree)
assert errors == []
def run_pipeline(text):
main_error1 = ["A class Main with a method main most be provided"]
main_error2 = ['"main" method in class Main does not receive any parameters']
# define grammar
grammar, idx, string, num = define_cool_grammar()
try:
tokens = tokenize_cool_text(grammar, idx, string, num, text)
parser = LR1Parser(grammar)
parse, operations = parser([t.token_type for t in tokens])
# print("\n".join(repr(x) for x in parse))
# print(operations)
ast = evaluate_reverse_parse(parse, operations, tokens)
formatter = FormatVisitorST()
tree = formatter.visit(ast)
if initial_ast in selected_options:
st.header("Initial Tree:")
print_array(tree)
errors = []
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
checker.visit(ast, None)
if errors != [] and errors != main_error1 and errors != main_error2:
st.header("Sorry we found some errors in your code:")
print_array(errors)
else:
if errors == main_error1 or errors == main_error2:
st.header("Warning")
st.write("We will continue the analisis but note that:")
st.write(errors[0])
errors = []
tset_builder = TSetBuilder(context, errors)
tset = tset_builder.visit(ast, None)
tset_reducer = TSetReducer(context, errors)
reduced_set = tset_reducer.visit(ast, tset)
tset_merger = TSetMerger(context, errors)
tset_merger.visit(ast, reduced_set)
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
checker.visit(ast, None)
if errors != [] and errors != main_error1 and errors != main_error2:
st.header("Sorry we found some errors in your code:")
print_array(errors)
if reduced_sets in selected_options:
st.header("Reduced Sets")
print_tset(reduced_set)
if final_ast in selected_options:
tree = formatter.visit(ast)
st.header("Final Tree:")
print_array(tree)
except Error as error:
st.header("Sorry an error occur while tokenizing text:")
st.write(str(error))
def test():
text = """
class A {
a : String ;
b : AUTO_TYPE ;
c : AUTO_TYPE <- 0 ;
d : Object <- while c loop c + 1 pool ; (*first and second errors*)
j : AUTO_TYPE ;
l : AUTO_TYPE ;
fact ( n : AUTO_TYPE ) : AUTO_TYPE { if n < 0 then 1 else n + fact ( n - 1 ) fi } ;
step ( p : AUTO_TYPE ) : AUTO_TYPE {
b <-
{
p + 5 ;
j <- p ; (*third error*)
p <- false ;
isvoid d ;
l @ Point . main ( ) ;
l.main();
}
} ;
} ;
class Point inherits A {
h : AUTO_TYPE <- "debe ser tipo string" ;
k : AUTO_TYPE ;
main ( ) : AUTO_TYPE {
let i : AUTO_TYPE <- new A in {
isvoid i ; (*Puede lanzar error semantico*)
}
} ;
ackermann ( m : AUTO_TYPE , n : AUTO_TYPE ) : AUTO_TYPE {
if m < 0 then 1 else
if n < 0 then ackermann ( m - 1 , 1 ) else
ackermann ( m - 1 , ackermann ( m , n - 1 ) )
fi
fi
} ;
} ;
"""
ast = run_pipeline(text)
errors = []
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
checker.visit(ast, None)
if errors != ["A class Main with a method main most be provided"]:
print(errors)
assert False
tset_builder = TSetBuilder(context, errors)
tset = tset_builder.visit(ast, None)
tset_reducer = TSetReducer(context, errors)
reduced_set = tset_reducer.visit(ast, tset)
tset_merger = TSetMerger(context, errors)
tset_merger.visit(ast, reduced_set)
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
checker.visit(ast, None)
formatter = FormatVisitor()
tree = formatter.visit(ast)
print("Errors:", errors)
print("Context:")
print(context)
print(reduced_set)
print(tree)
assert errors == [
"A class Main with a method main most be provided",
"A class Main with a method main most be provided",
"Expression after 'while' must be bool, current is Object",
'Operation is not defined between "Object" and "Int".',
'Cannot convert "Object" into "Int".',
]
def test():
text = """
class Main {
main (): Object {
0
};
f(a: AUTO_TYPE, b: AUTO_TYPE): AUTO_TYPE {
if a = 1 then b else
g(a + 1, b / 1)
fi
};
g(a: AUTO_TYPE, b: AUTO_TYPE): AUTO_TYPE {
if b = 1 then a else
f(a / 2, b + 1)
fi
};
};
"""
ast = run_pipeline(text)
errors = []
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
checker.visit(ast, None)
print(errors)
if errors != []:
print(errors)
assert False
tset_builder = TSetBuilder(context, errors)
tset = tset_builder.visit(ast, None)
tset_reducer = TSetReducer(context, errors)
reduced_set = tset_reducer.visit(ast, tset)
tset_merger = TSetMerger(context, errors)
tset_merger.visit(ast, reduced_set)
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
checker.visit(ast, None)
formatter = FormatVisitor()
tree = formatter.visit(ast)
print("Errors:", errors)
print("Context:")
print(context)
print(reduced_set)
print(tree)
assert errors == []
def test():
text = """
class A {
b : AUTO_TYPE ;
a : AUTO_TYPE ;
f ( ) : Int { {
let x : AUTO_TYPE <- a + b in x ;
} };
};
"""
ast = run_pipeline(text)
errors = []
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
checker.visit(ast, None)
if errors != ["A class Main with a method main most be provided"]:
print(errors)
assert False
tset_builder = TSetBuilder(context, errors)
tset = tset_builder.visit(ast, None)
tset_reducer = TSetReducer(context, errors)
reduced_set = tset_reducer.visit(ast, tset)
tset_merger = TSetMerger(context, errors)
tset_merger.visit(ast, reduced_set)
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
checker.visit(ast, None)
formatter = FormatVisitor()
tree = formatter.visit(ast)
print("Errors:", errors)
print("Context:")
print(context)
print(reduced_set)
print(tree)
assert errors == [
"A class Main with a method main most be provided",
"A class Main with a method main most be provided",
]
def test():
text = """
class Main {
pp : AUTO_TYPE;
main() : AUTO_TYPE {
pp <- self
};
};
"""
ast = run_pipeline(text)
errors = []
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
checker.visit(ast, None)
print(errors)
if errors != []:
print(errors)
assert False
tset_builder = TSetBuilder(context, errors)
tset = tset_builder.visit(ast, None)
tset_reducer = TSetReducer(context, errors)
reduced_set = tset_reducer.visit(ast, tset)
tset_merger = TSetMerger(context, errors)
tset_merger.visit(ast, reduced_set)
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
checker.visit(ast, None)
formatter = FormatVisitor()
tree = formatter.visit(ast)
print("Errors:", errors)
print("Context:")
print(context)
print(reduced_set)
print(tree)
assert errors == []
def test():
# text = """
# class A {
# f ( a : Int , d : Int ) : Int {
# d <- False
# };
# };
# class B inherits A {
# f ( a : A , d : Int ) : A {
# d <- True
# };
# };
# """
text = """
class Cons {
xcar : Int ;
xcdr : String ;
isNill ( ) : Bool {
false
} ;
init ( hd : Int , tl : String ) : AUTO_TYPE {
{
xcar <- hd ;
xcdr <- tl ;
self;
}
} ;
} ;
"""
print("corriendo")
ast = run_pipeline(text)
errors = []
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
checker.visit(ast, None)
if errors != ["A class Main with a method main most be provided"]:
print(errors)
assert False
tset_builder = TSetBuilder(context, errors)
tset = tset_builder.visit(ast, None)
tset_reducer = TSetReducer(context, errors)
reduced_set = tset_reducer.visit(ast, tset)
tset_merger = TSetMerger(context, errors)
tset_merger.visit(ast, reduced_set)
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
checker.visit(ast, None)
formatter = FormatVisitor()
tree = formatter.visit(ast)
if errors != [
"A class Main with a method main most be provided",
"A class Main with a method main most be provided",
]:
print("Errors:", errors)
print("Context:")
print(context)
print(reduced_set)
print(tree)
assert False
final_tree = """__ProgramNode [<class> ... <class>]__ClassDeclarationNode: class Cons { <feature> ... <feature> }__AttrDeclarationNode: xcar : Int <- <exp>__NONE__AttrDeclarationNode: xcdr : String <- <exp>__NONE__FuncDeclarationNode: isNill() : Bool { <body> }__ BooleanNode: false__FuncDeclarationNode: init(hd:Int, tl:String) : Cons { <body> }__BlockNode: {<exp>; ... <exp>;}__AssignNode: xcar <- <expr>__ VariableNode: hd__AssignNode: xcdr <- <expr>__ VariableNode: tl__ VariableNode: self"""
tree = tree.replace("\t", "")
tree = tree.replace("\n", "")
tree = tree.replace("\\", "")
print(tree)
assert tree == final_tree
def test():
text = """
class A {
a : String ;
b : Bool ;
c : Int <- 0 ;
d : Object <- while c < 1 loop c = c + 1 pool ;
step ( p : AUTO_TYPE ) : AUTO_TYPE { p . translate ( 1 , 1 ) } ;
} ;
class Point {
step ( p : AUTO_TYPE ) : AUTO_TYPE { p . translate ( 1 , 1 ) } ;
main ( ) : Object {
let p : AUTO_TYPE <- new Point in {
step ( p ) ; (*Puede lanzar error semantico*)
}
} ;
} ;
class B inherits A {
e : Bool ;
step ( p : AUTO_TYPE ) : AUTO_TYPE { p } ;
test ( e : Int ) : Bool {
{
let x : Int <- 4 in e + ~ x ;
case 5 + 4 of
f : Bool => f ;
g : Bool => not g ;
esac ;
self . step ( e ) ;
}
} ;
} ;
class C {
a : B ;
b : Int <- 8 ;
c : Bool <- false ;
m ( ) : Bool {
{
a @ A . step ( b ) ;
if not c then true else false fi ;
a . step ( b ) ;
}
} ;
} ;
"""
ast = run_pipeline(text)
errors = []
collector = TypeCollector(errors)
collector.visit(ast)
context = collector.context
builder = TypeBuilder(context, errors)
builder.visit(ast)
checker = TypeChecker(context, errors)
scope = checker.visit(ast, None)
tset_builder = TSetBuilder(context, errors)
tset = tset_builder.visit(ast, None)
print("Errors:", errors)
print("Context:")
print(context)
print(tset)
assert errors == ["A class Main with a method main most be provided"]