mirror of
https://github.com/ton-blockchain/ton
synced 2025-03-09 15:40:10 +00:00
f3e620f48c
This commit introduces nullable types `T?` that are distinct from non-nullable `T`. Example: `int?` (int or null) and `int` are different now. Previously, `null` could be assigned to any primitive type. Now, it can be assigned only to `T?`. A non-null assertion operator `!` was also introduced, similar to `!` in TypeScript and `!!` in Kotlin. If `int?` still occupies 1 stack slot, `(int,int)?` and other nullable tensors occupy N+1 slots, the last for "null precedence". `v == null` actually compares that slot. Assigning `(int,int)` to `(int,int)?` implicitly creates a null presence slot. Assigning `null` to `(int,int)?` widens this null value to 3 slots. This is called "type transitioning". All stdlib functions prototypes have been updated to reflect whether they return/accept a nullable or a strict value. This commit also contains refactoring from `const FunctionData*` to `FunctionPtr` and similar.
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(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
|