refactor builtin types in binder (#1821)

Small rename for the public API:

- renames the public `PublicBuiltin` type to just `Builtin`, as it is
used in the public API, and the "Public" prefix is redundant.
- renames the internal `Builtin` type to `InternalBuiltin`, to make it
clear that this should not be leaked to the public API.

Author: OmarTawfik

crates/solidity-v2/outputs/cargo/semantic/generated/public_api.txt

@@ -2,7 +2,7 @@ use std::collections::{HashMap, HashSet, VecDeque};
 
 use slang_solidity_v2_common::nodes::NodeId;
 
-use super::built_ins::BuiltIn;
+use super::built_ins::InternalBuiltIn;
 use super::types::{Type, TypeId};
 
 mod definitions;
@@ -58,7 +58,7 @@ pub enum Typing {
     /// resolves to `Resolution::BuiltIn(Addmod)` and will type to
     /// `Typing::BuiltIn(Addmod)` which in turn will type to the `uint256` type
     /// when evaluated in the context of a function call.
-    BuiltIn(BuiltIn),
+    BuiltIn(InternalBuiltIn),
     /// A special typing that's used as the result of applying the `new`
     /// operator, and will type to a contract reference when evaluated as a
     /// function call.

crates/solidity-v2/outputs/cargo/semantic/src/binder/mod.rs

@@ -1,7 +1,7 @@
 use slang_solidity_v2_common::nodes::NodeId;
 use slang_solidity_v2_ir::ir;
 
-use crate::built_ins::BuiltIn;
+use crate::built_ins::InternalBuiltIn;
 
 //////////////////////////////////////////////////////////////////////////////
 // References
@@ -30,7 +30,7 @@ pub enum Resolution {
     /// The symbol refers to a Solidity built-in of some kind. The possible
     /// variants are encoded in an enum and the behaviour of each is encoded in
     /// the `built_ins.rs` module.
-    BuiltIn(BuiltIn),
+    BuiltIn(InternalBuiltIn),
 }
 
 impl Reference {
@@ -106,8 +106,8 @@ impl From<Vec<NodeId>> for Resolution {
     }
 }
 
-impl From<Option<BuiltIn>> for Resolution {
-    fn from(value: Option<BuiltIn>) -> Self {
+impl From<Option<InternalBuiltIn>> for Resolution {
+    fn from(value: Option<InternalBuiltIn>) -> Self {
         if let Some(built_in) = value {
             Self::BuiltIn(built_in)
         } else {

crates/solidity-v2/outputs/cargo/semantic/src/binder/references.rs

@@ -1,5 +1,5 @@
 use slang_solidity_v2_common::versions::{LanguageVersion, LanguageVersionSpecifier};
-use slang_solidity_v2_common::built_ins::BuiltIn as PublicBuiltIn;
+use slang_solidity_v2_common::built_ins::BuiltIn;
 use slang_solidity_v2_common::nodes::NodeId;
 use crate::types::TypeId;
 
@@ -9,7 +9,7 @@ use crate::types::TypeId;
 /// `.push()` or `AraryPush` needs to carry the type of the original array to
 /// correctly resolve the type in a function call context.
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-pub enum BuiltIn {
+pub enum InternalBuiltIn {
     {% for context in model.language.built_ins -%}
     {% for scope in context.scopes -%}
     {% for definition in scope.definitions %}
@@ -22,17 +22,17 @@ pub enum BuiltIn {
     {% endfor %}
 }
 
-impl BuiltIn {
+impl InternalBuiltIn {
     /// Converts this internal built-in representation to the public enum type
     /// defined in the `common` crate.
     #[allow(clippy::too_many_lines)]
-    pub fn to_public(&self) -> PublicBuiltIn {
+    pub fn to_public(&self) -> BuiltIn {
         match self {
             {% for context in model.language.built_ins -%}
             {% for scope in context.scopes -%}
             {% for definition in scope.definitions %}
             Self::{{ definition.name }}{% if definition.internal_parameter %}(_){% endif %} =>
-              PublicBuiltIn::{{ definition.name }},
+              BuiltIn::{{ definition.name }},
             {%- endfor %}
             {% endfor -%}
             {% endfor %}

crates/solidity-v2/outputs/cargo/semantic/src/built_ins/internal.generated.rs

@@ -3,7 +3,7 @@ use ruint::aliases::U256;
 use sha3::{Digest, Keccak256};
 use slang_solidity_v2_ir::ir;
 
-use crate::built_ins::BuiltIn;
+use crate::built_ins::InternalBuiltIn;
 use crate::types::{literals, Number};
 
 pub(crate) fn evaluate_compile_time_usize_constant<Scope>(
@@ -42,7 +42,7 @@ pub(crate) enum ComptimeResolution<Scope> {
         value: ir::Expression,
         target_scope: Scope,
     },
-    BuiltIn(BuiltIn),
+    BuiltIn(InternalBuiltIn),
 }
 
 pub(crate) trait ConstantIdentifierResolver<Scope> {
@@ -257,7 +257,7 @@ impl<Scope> CompileConstantEvaluator<'_, Scope> {
             .identifier_resolver
             .resolve_identifier_in_scope(operand.unparse(), scope);
         match resolution {
-            ComptimeResolution::BuiltIn(BuiltIn::Erc7201) => {
+            ComptimeResolution::BuiltIn(InternalBuiltIn::Erc7201) => {
                 self.evaluate_erc7201_built_in_call(&call.arguments)
             }
             _ => None,
@@ -377,7 +377,7 @@ mod tests {
                     target_scope: target_scope.clone(),
                 }
             } else if self.recognise_erc7201 && identifier == "erc7201" {
-                ComptimeResolution::BuiltIn(BuiltIn::Erc7201)
+                ComptimeResolution::BuiltIn(InternalBuiltIn::Erc7201)
             } else {
                 ComptimeResolution::Unresolved
             }

crates/solidity-v2/outputs/cargo/semantic/src/built_ins/internal.rs.jinja2

@@ -8,7 +8,7 @@ use slang_solidity_v2_ir::ir::visitor::Visitor;
 use super::evaluator::evaluate_compile_time_integer_constant;
 use super::Pass;
 use crate::binder::{Definition, Reference, Resolution, Scope, Typing, UsingDirective};
-use crate::built_ins::BuiltIn;
+use crate::built_ins::InternalBuiltIn;
 use crate::types::{ContractType, DataLocation, EnumType, InterfaceType, LibraryType, Type};
 
 impl Visitor for Pass<'_> {
@@ -437,7 +437,7 @@ impl Visitor for Pass<'_> {
     fn enter_catch_clause_error(&mut self, node: &ir::CatchClauseError) -> bool {
         if let Some(name) = &node.name {
             let resolution = match name.unparse() {
-                "Error" | "Panic" => Resolution::BuiltIn(BuiltIn::ErrorOrPanic),
+                "Error" | "Panic" => Resolution::BuiltIn(InternalBuiltIn::ErrorOrPanic),
                 _ => Resolution::Unresolved,
             };
             let reference = Reference::new(Arc::clone(name), resolution);
@@ -455,7 +455,7 @@ impl Visitor for Pass<'_> {
     fn leave_type_expression(&mut self, node: &ir::TypeExpression) {
         let type_id = self.resolve_type_name(&node.type_name, Some(DataLocation::Memory));
         let typing = type_id.map_or(Typing::Unresolved, |type_id| {
-            Typing::BuiltIn(BuiltIn::Type(type_id))
+            Typing::BuiltIn(InternalBuiltIn::Type(type_id))
         });
         self.binder.set_node_typing(node.id(), typing);
     }

crates/solidity-v2/outputs/cargo/semantic/src/built_ins/mod.rs

@@ -4,7 +4,7 @@ use slang_solidity_v2_ir::ir;
 
 use super::Pass;
 use crate::binder::{Definition, Resolution, Typing};
-use crate::built_ins::BuiltIn;
+use crate::built_ins::InternalBuiltIn;
 use crate::passes::common::node_id_for_expression_typing;
 use crate::types::{
     literals, AddressType, ContractType, DataLocation, EnumType, FixedSizeArrayType, FunctionType,
@@ -438,7 +438,9 @@ impl Pass<'_> {
             // Special case: for `abi.decode` we need to register the types
             // given as the second argument and we need a mutable `TypeRegistry`
             // for that.
-            Typing::BuiltIn(BuiltIn::AbiDecode) => self.typing_of_abi_decode(&argument_typings),
+            Typing::BuiltIn(InternalBuiltIn::AbiDecode) => {
+                self.typing_of_abi_decode(&argument_typings)
+            }
             Typing::BuiltIn(built_in) => self
                 .built_ins_resolver()
                 .typing_of_function_call(&built_in, &argument_typings),

crates/solidity-v2/outputs/cargo/semantic/src/passes/p3_type_definitions/evaluator.rs

@@ -5,7 +5,7 @@ use slang_solidity_v2_ir::ir::visitor::Visitor;
 
 use super::Pass;
 use crate::binder::{Reference, Resolution, Typing};
-use crate::built_ins::BuiltIn;
+use crate::built_ins::InternalBuiltIn;
 use crate::passes::common::node_id_for_string_expression_typing;
 use crate::types::{
     ArrayType, DataLocation, FixedSizeArrayType, MappingType, Number, TupleType, Type,
@@ -119,7 +119,7 @@ impl Visitor for Pass<'_> {
         if let ir::Expression::Identifier(identifier) = node {
             let symbol = identifier.unparse();
             let resolution = if symbol == "_" && self.is_in_modifier_scope() {
-                Resolution::BuiltIn(BuiltIn::ModifierUnderscore)
+                Resolution::BuiltIn(InternalBuiltIn::ModifierUnderscore)
             } else {
                 let scope_id = self.current_scope_id();
                 self.filter_overriden_definitions(self.resolve_symbol_in_scope(scope_id, symbol))