mirror of
https://github.com/ton-blockchain/ton
synced 2025-02-12 11:12:16 +00:00
799e2d1265
FunC's (and Tolk's before this PR) type system is based on Hindley-Milner.
This is a common approach for functional languages, where
types are inferred from usage through unification.
As a result, type declarations are not necessary:
() f(a,b) { return a+b; } // a and b now int, since `+` (int, int)
While this approach works for now, problems arise with the introduction
of new types like bool, where `!x` must handle both int and bool.
It will also become incompatible with int32 and other strict integers.
This will clash with structure methods, struggle with proper generics,
and become entirely impractical for union types.
This PR completely rewrites the type system targeting the future.
1) type of any expression is inferred and never changed
2) this is available because dependent expressions already inferred
3) forall completely removed, generic functions introduced
(they work like template functions actually, instantiated while inferring)
4) instantiation `<...>` syntax, example: `t.tupleAt<int>(0)`
5) `as` keyword, for example `t.tupleAt(0) as int`
6) methods binding is done along with type inferring, not before
("before", as worked previously, was always a wrong approach)
190 lines
9.4 KiB
C++
190 lines
9.4 KiB
C++
/*
|
|
This file is part of TON Blockchain Library.
|
|
|
|
TON Blockchain Library is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
TON Blockchain Library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with TON Blockchain Library. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
#pragma once
|
|
|
|
#include "ast.h"
|
|
#include "platform-utils.h"
|
|
|
|
/*
|
|
* A module implementing base functionality of read-only traversing a vertex tree.
|
|
* Since a vertex in general doesn't store a vector of children, iterating is possible only for concrete node_type.
|
|
* E.g., for ast_if_statement, visit nodes cond, if-body and else-body. For ast_string_const, nothing. And so on.
|
|
* Visitors below are helpers to inherit from and handle specific vertex types.
|
|
*
|
|
* Note, that absence of "children" in ASTNodeBase is not a drawback. Instead, it encourages you to think
|
|
* about types and match the type system.
|
|
*
|
|
* The visitor is read-only, it does not modify visited nodes (except if you purposely call mutating methods).
|
|
* For example, if you want to replace "beginCell()" call with "begin_cell", a visitor isn't enough for you.
|
|
* To replace vertices, consider another API: ast-replacer.h.
|
|
*/
|
|
|
|
namespace tolk {
|
|
|
|
class ASTVisitor {
|
|
protected:
|
|
GNU_ATTRIBUTE_ALWAYS_INLINE static void visit_children(const ASTExprLeaf* v) {
|
|
static_cast<void>(v);
|
|
}
|
|
|
|
GNU_ATTRIBUTE_ALWAYS_INLINE void visit_children(const ASTExprUnary* v) {
|
|
visit(v->child);
|
|
}
|
|
|
|
GNU_ATTRIBUTE_ALWAYS_INLINE void visit_children(const ASTExprBinary* v) {
|
|
visit(v->lhs);
|
|
visit(v->rhs);
|
|
}
|
|
|
|
GNU_ATTRIBUTE_ALWAYS_INLINE void visit_children(const ASTExprVararg* v) {
|
|
for (AnyExprV child : v->children) {
|
|
visit(child);
|
|
}
|
|
}
|
|
|
|
GNU_ATTRIBUTE_ALWAYS_INLINE void visit_children(const ASTStatementUnary* v) {
|
|
visit(v->child);
|
|
}
|
|
|
|
GNU_ATTRIBUTE_ALWAYS_INLINE void visit_children(const ASTStatementVararg* v) {
|
|
for (AnyV child : v->children) {
|
|
visit(child);
|
|
}
|
|
}
|
|
|
|
GNU_ATTRIBUTE_ALWAYS_INLINE static void visit_children(const ASTOtherLeaf* v) {
|
|
static_cast<void>(v);
|
|
}
|
|
|
|
GNU_ATTRIBUTE_ALWAYS_INLINE void visit_children(const ASTOtherVararg* v) {
|
|
for (AnyV child : v->children) {
|
|
visit(child);
|
|
}
|
|
}
|
|
|
|
virtual void visit(AnyV v) = 0;
|
|
|
|
public:
|
|
virtual ~ASTVisitor() = default;
|
|
};
|
|
|
|
class ASTVisitorFunctionBody : public ASTVisitor {
|
|
protected:
|
|
using parent = ASTVisitorFunctionBody;
|
|
|
|
// expressions
|
|
virtual void visit(V<ast_empty_expression> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_parenthesized_expression> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_tensor> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_typed_tuple> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_reference> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_local_var_lhs> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_local_vars_declaration> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_int_const> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_string_const> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_bool_const> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_null_keyword> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_argument> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_argument_list> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_dot_access> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_function_call> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_underscore> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_assign> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_set_assign> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_unary_operator> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_binary_operator> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_ternary_operator> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_cast_as_operator> v) { return visit_children(v); }
|
|
// statements
|
|
virtual void visit(V<ast_empty_statement> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_sequence> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_return_statement> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_if_statement> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_repeat_statement> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_while_statement> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_do_while_statement> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_throw_statement> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_assert_statement> v) { return visit_children(v); }
|
|
virtual void visit(V<ast_try_catch_statement> v) { return visit_children(v); }
|
|
|
|
void visit(AnyV v) final {
|
|
switch (v->type) {
|
|
// expressions
|
|
case ast_empty_expression: return visit(v->as<ast_empty_expression>());
|
|
case ast_parenthesized_expression: return visit(v->as<ast_parenthesized_expression>());
|
|
case ast_tensor: return visit(v->as<ast_tensor>());
|
|
case ast_typed_tuple: return visit(v->as<ast_typed_tuple>());
|
|
case ast_reference: return visit(v->as<ast_reference>());
|
|
case ast_local_var_lhs: return visit(v->as<ast_local_var_lhs>());
|
|
case ast_local_vars_declaration: return visit(v->as<ast_local_vars_declaration>());
|
|
case ast_int_const: return visit(v->as<ast_int_const>());
|
|
case ast_string_const: return visit(v->as<ast_string_const>());
|
|
case ast_bool_const: return visit(v->as<ast_bool_const>());
|
|
case ast_null_keyword: return visit(v->as<ast_null_keyword>());
|
|
case ast_argument: return visit(v->as<ast_argument>());
|
|
case ast_argument_list: return visit(v->as<ast_argument_list>());
|
|
case ast_dot_access: return visit(v->as<ast_dot_access>());
|
|
case ast_function_call: return visit(v->as<ast_function_call>());
|
|
case ast_underscore: return visit(v->as<ast_underscore>());
|
|
case ast_assign: return visit(v->as<ast_assign>());
|
|
case ast_set_assign: return visit(v->as<ast_set_assign>());
|
|
case ast_unary_operator: return visit(v->as<ast_unary_operator>());
|
|
case ast_binary_operator: return visit(v->as<ast_binary_operator>());
|
|
case ast_ternary_operator: return visit(v->as<ast_ternary_operator>());
|
|
case ast_cast_as_operator: return visit(v->as<ast_cast_as_operator>());
|
|
// statements
|
|
case ast_empty_statement: return visit(v->as<ast_empty_statement>());
|
|
case ast_sequence: return visit(v->as<ast_sequence>());
|
|
case ast_return_statement: return visit(v->as<ast_return_statement>());
|
|
case ast_if_statement: return visit(v->as<ast_if_statement>());
|
|
case ast_repeat_statement: return visit(v->as<ast_repeat_statement>());
|
|
case ast_while_statement: return visit(v->as<ast_while_statement>());
|
|
case ast_do_while_statement: return visit(v->as<ast_do_while_statement>());
|
|
case ast_throw_statement: return visit(v->as<ast_throw_statement>());
|
|
case ast_assert_statement: return visit(v->as<ast_assert_statement>());
|
|
case ast_try_catch_statement: return visit(v->as<ast_try_catch_statement>());
|
|
#ifdef TOLK_DEBUG
|
|
case ast_asm_body:
|
|
throw UnexpectedASTNodeType(v, "ASTVisitor; forgot to filter out asm functions in should_visit_function()?");
|
|
#endif
|
|
default:
|
|
throw UnexpectedASTNodeType(v, "ASTVisitorFunctionBody::visit");
|
|
}
|
|
}
|
|
|
|
public:
|
|
virtual bool should_visit_function(const FunctionData* fun_ref) = 0;
|
|
|
|
virtual void start_visiting_function(const FunctionData* fun_ref, V<ast_function_declaration> v_function) {
|
|
visit(v_function->get_body());
|
|
}
|
|
};
|
|
|
|
|
|
const std::vector<const FunctionData*>& get_all_not_builtin_functions();
|
|
|
|
template<class BodyVisitorT>
|
|
void visit_ast_of_all_functions() {
|
|
BodyVisitorT visitor;
|
|
for (const FunctionData* fun_ref : get_all_not_builtin_functions()) {
|
|
if (visitor.should_visit_function(fun_ref)) {
|
|
visitor.start_visiting_function(fun_ref, fun_ref->ast_root->as<ast_function_declaration>());
|
|
}
|
|
}
|
|
}
|
|
|
|
} // namespace tolk
|