示例#1
0
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"]
示例#2
0
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"]
示例#3
0
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 == []
示例#4
0
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"]
示例#6
0
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 == []
示例#9
0
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 == []
示例#12
0
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".',
    ]
示例#14
0
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",
    ]
示例#16
0
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 == []
示例#17
0
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
示例#18
0
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"]