mirror of
https://github.com/ton-blockchain/ton
synced 2025-03-09 15:40:10 +00:00
7bcb8b895f
With the introduction of nullable types, we want the compiler to be smart in cases like > if (x == null) return; > // x is int now or > if (x == null) x = 0; > // x is int now These are called smart casts: when the type of variable at particular usage might differ from its declaration. Implementing smart casts is very challenging. They are based on building control-flow graph and handling every AST vertex with care. Actually, I represent cfg not a as a "graph with edges". Instead, it's a "structured DFS" for the AST: 1) at every point of inferring, we have "current flow facts" 2) when we see an `if (...)`, we create two derived contexts 3) after `if`, finalize them at the end and unify 4) if we detect unreachable code, we mark that context In other words, we get the effect of a CFG but in a more direct approach. That's enough for AST-level data-flow. Smart casts work for local variables and tensor/tuple indices. Compilation errors have been reworked and now are more friendly. There are also compilation warnings for always true/false conditions inside if, assert, etc.
102 lines
3.6 KiB
C++
102 lines
3.6 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 "src-file.h"
|
|
#include "fwd-declarations.h"
|
|
#include "td/utils/Status.h"
|
|
#include <vector>
|
|
|
|
namespace tolk {
|
|
|
|
// when a function is declared `f<T>`, this "<T>" is represented as this class
|
|
// (not at AST, but at symbol storage level)
|
|
struct GenericsDeclaration {
|
|
struct GenericsItem {
|
|
std::string_view nameT;
|
|
|
|
explicit GenericsItem(std::string_view nameT)
|
|
: nameT(nameT) {}
|
|
};
|
|
|
|
explicit GenericsDeclaration(std::vector<GenericsItem>&& itemsT)
|
|
: itemsT(std::move(itemsT)) {}
|
|
|
|
const std::vector<GenericsItem> itemsT;
|
|
|
|
std::string as_human_readable() const;
|
|
|
|
size_t size() const { return itemsT.size(); }
|
|
bool has_nameT(std::string_view nameT) const { return find_nameT(nameT) != -1; }
|
|
int find_nameT(std::string_view nameT) const;
|
|
std::string get_nameT(int idx) const { return static_cast<std::string>(itemsT[idx].nameT); }
|
|
};
|
|
|
|
// when a function call is `f<int>()`, this "<int>" is represented as this class
|
|
struct GenericsInstantiation {
|
|
const std::vector<TypePtr> substitutions; // <SomeStruct, int> for genericTs <T1, T2>
|
|
const SrcLocation loc; // first instantiation location
|
|
|
|
explicit GenericsInstantiation(SrcLocation loc, std::vector<TypePtr>&& substitutions)
|
|
: substitutions(std::move(substitutions))
|
|
, loc(loc) {
|
|
}
|
|
};
|
|
|
|
// this class helps to deduce Ts on the fly
|
|
// purpose: having `f<T>(value: T)` and call `f(5)`, deduce T = int
|
|
// while analyzing a call, arguments are handled one by one, by `auto_deduce_from_argument()`
|
|
// this class also handles manually specified substitutions like `f<int>(5)`
|
|
class GenericSubstitutionsDeduceForCall {
|
|
FunctionPtr fun_ref;
|
|
std::vector<TypePtr> substitutionTs;
|
|
bool manually_specified = false;
|
|
|
|
void provide_deducedT(const std::string& nameT, TypePtr deduced);
|
|
void consider_next_condition(TypePtr param_type, TypePtr arg_type);
|
|
|
|
public:
|
|
explicit GenericSubstitutionsDeduceForCall(FunctionPtr fun_ref);
|
|
|
|
bool is_manually_specified() const {
|
|
return manually_specified;
|
|
}
|
|
|
|
void provide_manually_specified(std::vector<TypePtr>&& substitutionTs);
|
|
TypePtr replace_by_manually_specified(TypePtr param_type) const;
|
|
TypePtr auto_deduce_from_argument(FunctionPtr cur_f, SrcLocation loc, TypePtr param_type, TypePtr arg_type);
|
|
int get_first_not_deduced_idx() const;
|
|
|
|
std::vector<TypePtr>&& flush() {
|
|
return std::move(substitutionTs);
|
|
}
|
|
};
|
|
|
|
struct GenericDeduceError final : std::exception {
|
|
std::string message;
|
|
explicit GenericDeduceError(std::string message)
|
|
: message(std::move(message)) { }
|
|
|
|
const char* what() const noexcept override {
|
|
return message.c_str();
|
|
}
|
|
};
|
|
|
|
std::string generate_instantiated_name(const std::string& orig_name, const std::vector<TypePtr>& substitutions);
|
|
FunctionPtr instantiate_generic_function(SrcLocation loc, FunctionPtr fun_ref, const std::string& inst_name, std::vector<TypePtr>&& substitutionTs);
|
|
|
|
} // namespace tolk
|