Refactored and cleaned up code for representing resolved ASTs

src/ast/function/mod.rs

@@ -2,7 +2,6 @@ mod parameters;
 
 use super::{Privacy, Stmt, Type};
 use crate::{name::Name, source_files::Source, tag::Tag};
-use derive_more::IsVariant;
 pub use parameters::{Parameter, Parameters};
 
 #[derive(Clone, Debug)]
@@ -16,12 +15,4 @@ pub struct Function {
     pub abide_abi: bool,
     pub tag: Option<Tag>,
     pub privacy: Privacy,
-    pub genericness: Genericness,
-}
-
-#[derive(Copy, Clone, Debug, PartialEq, IsVariant)]
-pub enum Genericness {
-    Concrete,
-    Contract,
-    Template,
 }

src/c/translation/function.rs

@@ -1,6 +1,6 @@
 use super::{parameters::has_parameters, types::get_name_and_type};
 use crate::{
-    ast::{self, AstFile, Function, Genericness, Parameter, Parameters, Privacy},
+    ast::{self, AstFile, Function, Parameter, Parameters, Privacy},
     c::parser::{
         error::ParseErrorKind, CTypedef, DeclarationSpecifiers, Declarator,
         ParameterDeclarationCore, ParameterTypeList, ParseError,
@@ -82,7 +82,6 @@ pub fn declare_function(
         abide_abi: true,
         tag: None,
         privacy: Privacy::Public,
-        genericness: Genericness::Concrete,
     });
 
     Ok(())

src/interpreter_env/mod.rs

@@ -1,8 +1,8 @@
 use crate::{
     ast::{
         AstFile, Call, Enum, EnumMember, ExprKind, Field, FieldInitializer, FillBehavior, Function,
-        Genericness, InterpreterSyscall, Language, Parameter, Parameters, Privacy, StmtKind,
-        StructLiteral, Structure, TypeKind,
+        InterpreterSyscall, Language, Parameter, Parameters, Privacy, StmtKind, StructLiteral,
+        Structure, TypeKind,
     },
     interpreter::{
         syscall_handler::{BuildSystemSyscallHandler, ProjectKind},
@@ -41,7 +41,6 @@ fn thin_void_function(name: impl Into<String>, syscall_kind: InterpreterSyscallK
         source,
         tag: None,
         privacy: Privacy::Public,
-        genericness: Genericness::Concrete,
     }
 }
 
@@ -78,7 +77,6 @@ fn thin_cstring_function(
         source,
         tag: None,
         privacy: Privacy::Public,
-        genericness: Genericness::Concrete,
     }
 }
 
@@ -106,7 +104,6 @@ pub fn setup_build_system_interpreter_symbols(file: &mut AstFile) {
         abide_abi: false,
         tag: Some(Tag::InterpreterEntryPoint),
         privacy: Privacy::Public,
-        genericness: Genericness::Concrete,
     });
 
     file.enums.push(Enum {
@@ -244,7 +241,6 @@ pub fn setup_build_system_interpreter_symbols(file: &mut AstFile) {
         source,
         tag: None,
         privacy: Privacy::Public,
-        genericness: Genericness::Concrete,
     });
 
     file.functions.push(Function {
@@ -288,7 +284,6 @@ pub fn setup_build_system_interpreter_symbols(file: &mut AstFile) {
         source,
         tag: None,
         privacy: Privacy::Public,
-        genericness: Genericness::Concrete,
     });
 
     file.functions.push(Function {
@@ -316,7 +311,6 @@ pub fn setup_build_system_interpreter_symbols(file: &mut AstFile) {
         source,
         tag: None,
         privacy: Privacy::Public,
-        genericness: Genericness::Concrete,
     });
 }
 

src/lower/mod.rs

@@ -9,10 +9,10 @@ mod structure;
 
 use self::error::{LowerError, LowerErrorKind};
 use crate::{
-    ast::CInteger,
+    ast::{CInteger, FloatSize},
     cli::BuildOptions,
     ir::{self, IntegerSign},
-    resolved::{self, FloatSize},
+    resolved,
     target::{Target, TargetOsExt},
 };
 use function::lower_function;

src/parser/parse_function.rs

@@ -4,7 +4,7 @@ use super::{
     Parser,
 };
 use crate::{
-    ast::{Function, Genericness, Parameters, Privacy, TypeKind},
+    ast::{Function, Parameters, Privacy, TypeKind},
     inflow::Inflow,
     name::Name,
     token::{Token, TokenKind},
@@ -18,14 +18,12 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
         let mut is_foreign = false;
         let mut abide_abi = false;
         let mut privacy = Privacy::Private;
-        let mut genericness = Genericness::Concrete;
 
         for annotation in annotations {
             match annotation.kind {
                 AnnotationKind::Foreign => is_foreign = true,
                 AnnotationKind::AbideAbi => abide_abi = true,
                 AnnotationKind::Public => privacy = Privacy::Public,
-                AnnotationKind::Template => genericness = Genericness::Template,
                 _ => return Err(self.unexpected_annotation(&annotation, Some("for function"))),
             }
         }
@@ -69,7 +67,6 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
             abide_abi,
             tag: None,
             privacy,
-            genericness,
         })
     }
 }

src/pragma_section/parse.rs

@@ -1,9 +1,6 @@
 use super::PragmaSection;
 use crate::{
-    ast::{
-        AstFile, Expr, ExprKind, Function, Genericness, Parameters, Privacy, Stmt, StmtKind,
-        TypeKind,
-    },
+    ast::{AstFile, Expr, ExprKind, Function, Parameters, Privacy, Stmt, StmtKind, TypeKind},
     diagnostics::ErrorDiagnostic,
     inflow::Inflow,
     name::Name,
@@ -117,7 +114,6 @@ impl PragmaSection {
                 abide_abi: false,
                 tag: None,
                 privacy: Privacy::Public,
-                genericness: Genericness::Concrete,
             });
         } else {
             return Err(Box::new(ParseError::expected(

src/resolve/expr/mod.rs

@@ -24,7 +24,8 @@ use super::{
 };
 use crate::{
     ast::{
-        self, CInteger, CIntegerAssumptions, ConformBehavior, Language, Settings, UnaryOperator,
+        self, CInteger, CIntegerAssumptions, ConformBehavior, IntegerKnown, Language, Settings,
+        UnaryOperator,
     },
     resolve::{
         error::ResolveErrorKind,
@@ -41,7 +42,6 @@ use crate::{
 };
 use ast::FloatSize;
 pub use basic_binary_operation::resolve_basic_binary_operator;
-use resolved::IntegerKnown;
 use std::collections::HashMap;
 
 pub struct ResolveExprCtx<'a, 'b> {

src/resolve/mod.rs

@@ -322,6 +322,7 @@ pub fn resolve<'a>(
                         None
                     }
                 }),
+                is_generic: false,
             });
 
             ctx.jobs.push_back(FuncJob::Regular(

src/resolved/block.rs

@@ -0,0 +1,27 @@
+use super::{Stmt, StmtKind, Type, TypeKind};
+use crate::source_files::Source;
+
+#[derive(Clone, Debug)]
+pub struct Block {
+    pub stmts: Vec<Stmt>,
+}
+
+impl Block {
+    pub fn new(stmts: Vec<Stmt>) -> Self {
+        Self { stmts }
+    }
+
+    pub fn get_result_type(&self, source: Source) -> Type {
+        if let Some(stmt) = self.stmts.last() {
+            match &stmt.kind {
+                StmtKind::Return(..) => None,
+                StmtKind::Expr(expr) => Some(expr.resolved_type.clone()),
+                StmtKind::Declaration(..) => None,
+                StmtKind::Assignment(..) => None,
+            }
+        } else {
+            None
+        }
+        .unwrap_or(TypeKind::Void.at(source))
+    }
+}

src/resolved/datatype/kind/anonymous_enum.rs

@@ -0,0 +1,15 @@
+use crate::{ast::EnumMember, resolved::Type, source_files::Source};
+use indexmap::IndexMap;
+
+#[derive(Clone, Debug)]
+pub struct AnonymousEnum {
+    pub resolved_type: Box<Type>,
+    pub source: Source,
+    pub members: IndexMap<String, EnumMember>,
+}
+
+impl PartialEq for AnonymousEnum {
+    fn eq(&self, other: &Self) -> bool {
+        self.resolved_type.eq(&other.resolved_type) && self.members.eq(&other.members)
+    }
+}

src/resolved/datatype/kind/fixed_array.rs

@@ -0,0 +1,7 @@
+use crate::resolved::Type;
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct FixedArray {
+    pub size: u64,
+    pub inner: Type,
+}

src/resolved/datatype/kind/function_pointer.rs

@@ -0,0 +1,8 @@
+use crate::resolved::{Parameter, Type};
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct FunctionPointer {
+    pub parameters: Vec<Parameter>,
+    pub return_type: Box<Type>,
+    pub is_cstyle_variadic: bool,
+}