Implement Vec in the standard library; Bug Fixes

core_lang/src/control_flow_analysis/analyze_return_paths.rs

@@ -206,9 +206,7 @@ fn connect_declaration<'sc>(
             connect_impl_trait(&trait_name, graph, methods, entry_node);
             vec![]
         }
-        SideEffect | ErrorRecovery => {
-            unreachable!("These are error cases and should be removed in the type checking stage. ")
-        }
+        SideEffect | ErrorRecovery => leaves.to_vec(),
     }
 }
 

core_lang/src/control_flow_analysis/dead_code_analysis.rs

@@ -375,9 +375,7 @@ fn connect_declaration<'sc>(
             connect_impl_trait(&trait_name, graph, methods, entry_node, tree_type)?;
             Ok(vec![])
         }
-        SideEffect | ErrorRecovery => {
-            unreachable!("These are error cases and should be removed in the type checking stage. ")
-        }
+        SideEffect | ErrorRecovery => Ok(vec![]),
     }
 }
 
@@ -853,6 +851,10 @@ fn connect_enum_instantiation<'sc>(
     vec![enum_instantiation_exit_idx]
 }
 
+/// Given a `TypedAstNode` that we know is not reached in the graph, construct a warning
+/// representing its unreached status. For example, we want to say "this function is never called"
+/// if the node is a function declaration, but "this trait is never used" if it is a trait
+/// declaration.
 fn construct_dead_code_warning_from_node<'sc>(node: &TypedAstNode<'sc>) -> CompileWarning<'sc> {
     match node {
         // if this is a function, struct, or trait declaration that is never called, then it is dead
@@ -886,7 +888,7 @@ fn construct_dead_code_warning_from_node<'sc>(node: &TypedAstNode<'sc>) -> Compi
             warning_content: Warning::DeadTrait,
         },
         TypedAstNode {
-            content: TypedAstNodeContent::Declaration(TypedDeclaration::EnumDeclaration(..)),
+            content: TypedAstNodeContent::Declaration(..),
             span,
         } => CompileWarning {
             span: span.clone(),

core_lang/src/error.rs

@@ -511,7 +511,7 @@ pub enum CompileError<'sc> {
     ModuleNotFound { span: Span<'sc>, name: String },
     #[error("\"{name}\" is a {actually}, not a struct. Fields can only be accessed on structs.")]
     NotAStruct {
-        name: &'sc str,
+        name: String,
         span: Span<'sc>,
         actually: String,
     },
@@ -526,7 +526,7 @@ pub enum CompileError<'sc> {
         span: Span<'sc>,
     },
     #[error("Could not find symbol \"{name}\" in this scope.")]
-    SymbolNotFound { span: Span<'sc>, name: &'sc str },
+    SymbolNotFound { span: Span<'sc>, name: String },
     #[error(
         "Because this if expression's value is used, an \"else\" branch is required and it must \
          return type \"{r#type}\""
@@ -586,10 +586,7 @@ pub enum CompileError<'sc> {
     },
     #[error("Unknown opcode: \"{op_name}\".")]
     UnrecognizedOp { op_name: &'sc str, span: Span<'sc> },
-    #[error(
-        "Unable to infer concrete type for partial type \"{ty}\". Type must be known at this \
-         point. Try providing an annotation or using a concrete type."
-    )]
+    #[error("Unknown type \"{ty}\".")]
     TypeMustBeKnown { ty: String, span: Span<'sc> },
     #[error("The value \"{val}\" is too large to fit in this 6-bit immediate spot.")]
     Immediate06TooLarge { val: u64, span: Span<'sc> },
@@ -641,6 +638,12 @@ pub enum CompileError<'sc> {
     },
     #[error("This imported file must be a library. It must start with \"library <name>\", where \"name\" is the name of the library this file contains.")]
     ImportMustBeLibrary { span: Span<'sc> },
+    #[error("An enum instantiaton cannot contain more than one value. This should be a single value of type {ty}.")]
+    MoreThanOneEnumInstantiator { span: Span<'sc>, ty: String },
+    #[error("This enum variant represents the unit type, so it should not be instantiated with any value.")]
+    UnnecessaryEnumInstantiator { span: Span<'sc> },
+    #[error("Trait \"{name}\" does not exist in this scope.")]
+    TraitNotFound { name: &'sc str, span: Span<'sc> },
 }
 
 impl<'sc> std::convert::From<TypeError<'sc>> for CompileError<'sc> {
@@ -797,6 +800,9 @@ impl<'sc> CompileError<'sc> {
             FileNotFound { span, .. } => span,
             FileCouldNotBeRead { span, .. } => span,
             ImportMustBeLibrary { span, .. } => span,
+            MoreThanOneEnumInstantiator { span, .. } => span,
+            UnnecessaryEnumInstantiator { span, .. } => span,
+            TraitNotFound { span, .. } => span,
         }
     }
 

core_lang/src/hll.pest

@@ -33,18 +33,22 @@ file_path         = { ident ~ ("/" ~ ident)* }
 include_statement = { include_keyword ~ file_path ~ alias? ~ ";"}
 alias             = { "as" ~ ident }
 // expressions
-expr_inner               = _{literal_value|if_exp|parenthesized_expression|asm_expression|code_block|func_app|struct_expression|delineated_path|method_exp|subfield_exp|var_exp|array_exp|match_expression|unit}
+expr_inner               = _{literal_value|if_exp|asm_expression|code_block|func_app|struct_expression|method_exp|struct_field_access|delineated_path|var_exp|array_exp|parenthesized_expression|match_expression|unit}
 parenthesized_expression =  {"(" ~ expr ~ ")"}
 // // op exps built in to expr to prevent left recursion
 expr                     =  {expr_inner ~ (op ~ expr_inner)*}
 func_app                 =  {fn_name ~ fn_args}
 fn_args                  =  { "(" ~ (expr ~ ("," ~ expr)*)? ~ ")" }
 fn_name                  =  {var_exp}
 var_exp                  =  {unary_op? ~ var_name_ident}
-method_exp               =  {subfield_exp ~ "(" ~ (expr ~ ("," ~ expr)*)? ~ ")"}
-subfield_exp             =  {(call_item ~ ".")+ ~ call_item}
-call_item                =  {ident}
-delineated_path          =  {path_component ~ ("(" ~ expr ~ ")")?}
+struct_field_access      =  {subfield_path}
+method_exp               =  {subfield_exp | fully_qualified_method}
+subfield_exp             =  {subfield_path ~ fn_args}
+// TODO subfield path should allow parenthesized expressions _or_ just idents  
+subfield_path            =  {(call_item ~ ".")+ ~ call_item}
+fully_qualified_method   =  {(path_ident ~ path_separator)* ~ "~" ~ type_name ~ path_separator ~ call_item ~ fn_args}
+call_item                =  {ident | "(" ~ expr ~ ")" }
+delineated_path          =  {path_component ~ fn_args?}
 path_component           =  {path_ident ~ (path_separator ~ path_ident)+}
 path_ident               =  {ident}
 
@@ -104,7 +108,7 @@ enum_fields       =  {enum_field_name ~ ":" ~ type_name ~ ("," ~ enum_field_name
 enum_name         =  {ident}
 enum_field_name   =  {ident}
 
-impl_self =  {impl_keyword ~ type_name ~ type_params? ~ trait_bounds? ~ ("{" ~ fn_decl* ~ "}")}
+impl_self =  {impl_keyword ~ type_params? ~ type_name ~  trait_bounds? ~ ("{" ~ fn_decl* ~ "}")}
 
 // // fn declaration
 fn_decl_params     =  {"(" ~ (fn_decl_param ~ ("," ~ fn_decl_param)*)? ~ ")"}
@@ -116,7 +120,7 @@ fn_decl_name       =  {ident}
 type_name          =  {(str_type|ident ~ type_params?)|unit}
 str_type           =  { "str" ~ "[" ~ basic_integer ~ "]" }
 trait_bounds       =  {"where" ~ (generic_type_param ~ ":" ~ trait_name) ~ ("," ~ generic_type_param ~ ":" ~ trait_name)*}
-generic_type_param = @{ident}
+generic_type_param =  {ident}
 
 // statements
 // // statements are basically non-expressions that don't alter the namespace like declarations do

core_lang/src/ident.rs

@@ -14,7 +14,7 @@ pub struct Ident<'sc> {
 }
 
 // custom implementation of Hash so that namespacing isn't reliant on the span itself, which will
-// always be different.
+// often be different.
 impl Hash for Ident<'_> {
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.primary_name.hash(state);

core_lang/src/parse_tree/declaration/type_parameter.rs

@@ -1,10 +1,11 @@
-use crate::error::*;
+use crate::{error::*, types::TypeInfo, Ident};
 use crate::{CompileError, Rule};
 use pest::iterators::Pair;
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) struct TypeParameter<'sc> {
-    pub(crate) name: &'sc str,
-    trait_constraint: Vec<TraitConstraint<'sc>>,
+    pub(crate) name: TypeInfo<'sc>,
+    pub(crate) name_ident: Ident<'sc>,
+    pub(crate) trait_constraints: Vec<TraitConstraint<'sc>>,
 }
 
 impl<'sc> TypeParameter<'sc> {
@@ -13,14 +14,19 @@ impl<'sc> TypeParameter<'sc> {
         where_clause_pair: Option<Pair<'sc, Rule>>,
     ) -> CompileResult<'sc, Vec<TypeParameter<'sc>>> {
         let mut errors = Vec::new();
+        let mut warnings = vec![];
         let mut params: Vec<TypeParameter> = match type_params_pair {
-            Some(type_params_pair) => type_params_pair
-                .into_inner()
-                .map(|pair| TypeParameter {
-                    name: pair.as_str(),
-                    trait_constraint: Vec::new(),
-                })
-                .collect(),
+            Some(type_params_pair) => {
+                let mut buf = vec![];
+                for pair in type_params_pair.into_inner() {
+                    buf.push(TypeParameter {
+                        name_ident: eval!(Ident::parse_from_pair, warnings, errors, pair, continue),
+                        name: eval!(TypeInfo::parse_from_pair, warnings, errors, pair, continue),
+                        trait_constraints: Vec::new(),
+                    });
+                }
+                buf
+            }
             None => {
                 // no type params specified, ensure where clause is empty
                 if let Some(where_clause_pair) = where_clause_pair {
@@ -44,32 +50,39 @@ impl<'sc> TypeParameter<'sc> {
                     assert_eq!(trait_constraint.as_rule(), Rule::trait_name);
                     // assign trait constraints to above parsed type params
                     // find associated type name
-                    let param_to_edit = match params
-                        .iter_mut()
-                        .find(|TypeParameter { name, .. }| *name == type_param.as_str())
-                    {
-                        Some(o) => o,
-                        None => {
-                            errors.push(CompileError::ConstrainedNonExistentType {
-                                type_name: type_param.as_str(),
-                                trait_name: trait_constraint.as_str(),
-                                span: trait_constraint.as_span(),
-                            });
-                            continue;
-                        }
-                    };
-                    param_to_edit.trait_constraint.push(TraitConstraint {
-                        name: trait_constraint.as_str(),
+                    let param_to_edit =
+                        match params.iter_mut().find(|TypeParameter { name_ident, .. }| {
+                            name_ident.primary_name == type_param.as_str()
+                        }) {
+                            Some(o) => o,
+                            None => {
+                                errors.push(CompileError::ConstrainedNonExistentType {
+                                    type_name: type_param.as_str(),
+                                    trait_name: trait_constraint.as_str(),
+                                    span: trait_constraint.as_span(),
+                                });
+                                continue;
+                            }
+                        };
+
+                    param_to_edit.trait_constraints.push(TraitConstraint {
+                        name: eval!(
+                            Ident::parse_from_pair,
+                            warnings,
+                            errors,
+                            trait_constraint,
+                            continue
+                        ),
                     });
                 }
             }
             None => (),
         }
-        ok(params, Vec::new(), errors)
+        ok(params, warnings, errors)
     }
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub(crate) struct TraitConstraint<'sc> {
-    name: &'sc str,
+    pub(crate) name: Ident<'sc>,
 }