Finished adding support for extern global variables declared in C, along with thread_local storage class

Author: IsaacShelton

Diff for: src/asg/expr/array_access.rs

@@ -1,9 +1,16 @@
 use super::Expr;
-use crate::asg::Type;
+use crate::asg::{Destination, Type};
+use derive_more::From;
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct ArrayAccess {
-    pub subject: Expr,
+    pub subject: ArrayDestination,
     pub item_type: Type,
     pub index: Expr,
 }
+
+#[derive(Clone, Debug, Hash, PartialEq, Eq, From)]
+pub enum ArrayDestination {
+    Expr(Expr),
+    Destination(Destination),
+}

Diff for: src/c/translation/function.rs

@@ -20,14 +20,15 @@ pub fn declare_function(
     diagnostics: &Diagnostics,
 ) -> Result<(), ParseError> {
     let source = declarator.source;
-    let (name, return_type, storage_class, function_specifier) = get_name_and_type(
-        ast_file,
-        typedefs,
-        declarator,
-        declaration_specifiers,
-        false,
-        diagnostics,
-    )?;
+    let (name, return_type, storage_class, function_specifier, _is_thread_local) =
+        get_name_and_type(
+            ast_file,
+            typedefs,
+            declarator,
+            declaration_specifiers,
+            false,
+            diagnostics,
+        )?;
     let mut required = vec![];
 
     if function_specifier.is_some() {
@@ -36,7 +37,7 @@ pub fn declare_function(
 
     if has_parameters(parameter_type_list) {
         for param in parameter_type_list.parameter_declarations.iter() {
-            let (name, ast_type, storage_class, function_specifier) = match &param.core {
+            let (name, ast_type, storage_class, function_specifier, _) = match &param.core {
                 ParameterDeclarationCore::Declarator(declarator) => get_name_and_type(
                     ast_file,
                     typedefs,

Diff for: src/c/translation/mod.rs

@@ -22,7 +22,7 @@ pub fn declare_named_declaration(
     typedefs: &mut HashMap<String, CTypedef>,
     diagnostics: &Diagnostics,
 ) -> Result<(), ParseError> {
-    let (name, ast_type, storage_class, function_specifier) = get_name_and_type(
+    let (name, ast_type, storage_class, function_specifier, is_thread_local) = get_name_and_type(
         ast_file,
         typedefs,
         declarator,
@@ -54,6 +54,28 @@ pub fn declare_named_declaration(
         return Ok(());
     }
 
+    if let Some(StorageClassSpecifier::Extern) = storage_class {
+        if let Some(function_specifier) = function_specifier {
+            diagnostics.push(WarningDiagnostic::new(
+                format!(
+                    "Function specifier '{}' on functions is not respected yet",
+                    function_specifier.as_str()
+                ),
+                declarator.source,
+            ));
+        }
+
+        ast_file.global_variables.push(ast::GlobalVar {
+            name,
+            ast_type,
+            source: declarator.source,
+            is_foreign: true,
+            is_thread_local,
+            privacy: Privacy::Public,
+        });
+        return Ok(());
+    }
+
     todo!(
         "declare_named_declaration unimplemented for non-typedef - {:#?}",
         declarator

Diff for: src/c/translation/types/composite.rs

@@ -54,7 +54,7 @@ pub fn make_composite(
                         for member_declarator in member.member_declarators.iter() {
                             match member_declarator {
                                 MemberDeclarator::Declarator(declarator) => {
-                                    let (name, ast_type, storage_class, function_specifier) =
+                                    let (name, ast_type, storage_class, function_specifier, _) =
                                         get_name_and_type(
                                             ast_file,
                                             typedefs,

Diff for: src/c/translation/types/mod.rs

@@ -28,6 +28,7 @@ pub struct TypeBase {
     pub ast_type: Type,
     pub storage_class: Option<StorageClassSpecifier>,
     pub function_specifier: Option<FunctionSpecifier>,
+    pub is_thread_local: bool,
 }
 
 #[derive(Debug)]
@@ -38,6 +39,7 @@ pub struct TypeBaseBuilder {
     pub concrete: Option<Type>,
     pub storage_class: Option<StorageClassSpecifier>,
     pub function_specifier: Option<FunctionSpecifier>,
+    pub is_thread_local: bool,
 }
 
 impl TypeBaseBuilder {
@@ -49,6 +51,7 @@ impl TypeBaseBuilder {
             concrete: None,
             storage_class: None,
             function_specifier: None,
+            is_thread_local: false,
         }
     }
 
@@ -71,6 +74,7 @@ impl TypeBaseBuilder {
             ast_type,
             storage_class: self.storage_class,
             function_specifier: self.function_specifier,
+            is_thread_local: false,
         })
     }
 
@@ -198,6 +202,7 @@ pub fn get_name_and_type(
         Type,
         Option<StorageClassSpecifier>,
         Option<FunctionSpecifier>,
+        bool,
     ),
     ParseError,
 > {
@@ -239,6 +244,7 @@ pub fn get_name_and_type(
         ast_type,
         type_base.storage_class,
         type_base.function_specifier,
+        type_base.is_thread_local,
     ))
 }
 
@@ -266,7 +272,7 @@ fn get_name_and_decorators(
                 for parameter in parameter_type_list.parameter_declarations.iter() {
                     let (parameter_name, parameter_type) = match &parameter.core {
                         ParameterDeclarationCore::Declarator(declarator) => {
-                            let (parameter_name, ast_type, _, _) = get_name_and_type(
+                            let (parameter_name, ast_type, _, _, _) = get_name_and_type(
                                 ast_file,
                                 typedefs,
                                 declarator,

Diff for: src/lower/expr/mod.rs

@@ -267,7 +267,15 @@ pub fn lower_expr(
             Ok(builder.push(ir::Instr::Load((member, ir_type))))
         }
         ExprKind::ArrayAccess(array_access) => {
-            let subject = lower_expr(builder, ir_module, &array_access.subject, function, asg)?;
+            let subject = match &array_access.subject {
+                asg::ArrayDestination::Expr(subject) => {
+                    lower_expr(builder, ir_module, subject, function, asg)?
+                }
+                asg::ArrayDestination::Destination(subject) => {
+                    lower_destination(builder, ir_module, subject, function, asg)?
+                }
+            };
+
             let index = lower_expr(builder, ir_module, &array_access.index, function, asg)?;
             let item_type = lower_type(ir_module, &builder.unpoly(&array_access.item_type)?, asg)?;
 
@@ -602,8 +610,15 @@ pub fn lower_destination(
             }))
         }
         DestinationKind::ArrayAccess(array_access) => {
-            let subject_pointer =
-                lower_expr(builder, ir_module, &array_access.subject, function, asg)?;
+            let subject_pointer = match &array_access.subject {
+                asg::ArrayDestination::Expr(subject) => {
+                    lower_expr(builder, ir_module, subject, function, asg)?
+                }
+                asg::ArrayDestination::Destination(subject) => {
+                    lower_destination(builder, ir_module, subject, function, asg)?
+                }
+            };
+
             let index = lower_expr(builder, ir_module, &array_access.index, function, asg)?;
             let item_type = lower_type(ir_module, &builder.unpoly(&array_access.item_type)?, asg)?;
 

Diff for: src/resolve/expr/array_access.rs

@@ -4,6 +4,7 @@ use crate::{
     ast,
     resolve::{
         conform::to_default::conform_expr_to_default_or_error,
+        destination::resolve_expr_to_destination,
         error::{ResolveError, ResolveErrorKind},
         Initialized,
     },
@@ -42,8 +43,17 @@ pub fn resolve_array_access_expr(
         c_integer_assumptions,
     )?;
 
-    let item_type = match &subject.ty.kind {
-        asg::TypeKind::Ptr(inner) => Ok((**inner).clone()),
+    let (item_type, subject) = match &subject.ty.kind {
+        asg::TypeKind::Ptr(inner) => {
+            let item_type = (**inner).clone();
+            let array_destination = subject.expr.into();
+            Ok((item_type, array_destination))
+        }
+        asg::TypeKind::FixedArray(fixed_array) => {
+            let item_type = fixed_array.inner.clone();
+            let array_destination = resolve_expr_to_destination(subject)?.into();
+            Ok((item_type, array_destination))
+        }
         bad_type => Err(ResolveErrorKind::CannotAccessMemberOf {
             bad_type: bad_type.to_string(),
         }
@@ -62,7 +72,7 @@ pub fn resolve_array_access_expr(
         item_type.clone(),
         asg::Expr::new(
             asg::ExprKind::ArrayAccess(Box::new(asg::ArrayAccess {
-                subject: subject.expr,
+                subject,
                 index: index.expr,
                 item_type,
             })),

Diff for: tests/success/c_global_variable_extern_thread_local/_.adept

@@ -0,0 +1,10 @@
+
+pragma => adept("3.0")
+
+#[foreign]
+func printf(format ptr#char, ...) int
+
+func main {
+    printf(c"errno = %s\n", strerror(errno))
+}
+

Diff for: tests/success/c_global_variable_extern_thread_local/errno.h

@@ -0,0 +1,10 @@
+
+#ifndef _C_ERRNO_H_INCLUDED
+#define _C_ERRNO_H_INCLUDED
+
+thread_local extern int errno;
+
+char *strerror(int errnum);
+
+#endif // _C_ERRNO_H_INCLUDED
+