Allow prefixes in any call path.

sway-core/src/asm_generation/expression/mod.rs

@@ -361,8 +361,7 @@ pub(crate) fn convert_expression_to_asm(
         }
         // ABI casts are purely compile-time constructs and generate no corresponding bytecode
         TypedExpressionVariant::AbiCast { .. } => ok(vec![], warnings, errors),
-        a => {
-            println!("unimplemented: {:?}", a);
+        _ => {
             errors.push(CompileError::Unimplemented(
                 "ASM generation has not yet been implemented for this.",
                 exp.span.clone(),

sway-core/src/control_flow_analysis/dead_code_analysis.rs

@@ -491,8 +491,9 @@ fn connect_trait_declaration(
 ) {
     graph.namespace.add_trait(
         CallPath {
-            suffix: decl.name.clone(),
             prefixes: vec![],
+            suffix: decl.name.clone(),
+            is_absolute: false,
         },
         entry_node,
     );
@@ -506,8 +507,9 @@ fn connect_abi_declaration(
 ) {
     graph.namespace.add_trait(
         CallPath {
-            suffix: decl.name.clone(),
             prefixes: vec![],
+            suffix: decl.name.clone(),
+            is_absolute: false,
         },
         entry_node,
     );

sway-core/src/parse_tree/call_path.rs

@@ -9,13 +9,17 @@ use pest::iterators::Pair;
 pub struct CallPath {
     pub prefixes: Vec<Ident>,
     pub suffix: Ident,
+    // If `is_absolute` is true, then this call path is an absolute path from
+    // the project root namespace. If not, then it is relative to the current namespace.
+    pub(crate) is_absolute: bool,
 }
 
 impl std::convert::From<Ident> for CallPath {
     fn from(other: Ident) -> Self {
         CallPath {
             prefixes: vec![],
             suffix: other,
+            is_absolute: false,
         }
     }
 }
@@ -66,10 +70,20 @@ impl CallPath {
         pair: Pair<Rule>,
         config: Option<&BuildConfig>,
     ) -> CompileResult<CallPath> {
+        assert!(pair.as_rule() == Rule::call_path || pair.as_rule() == Rule::call_path_);
         let mut warnings = vec![];
         let mut errors = vec![];
         let mut pairs_buf = vec![];
-        for pair in pair.into_inner() {
+        let stmt = pair.into_inner().next().unwrap();
+        let is_absolute = stmt.as_rule() == Rule::absolute_call_path
+            || stmt.as_rule() == Rule::absolute_call_path_;
+        let stmt = stmt.into_inner();
+        let it = if is_absolute {
+            stmt.skip(1)
+        } else {
+            stmt.skip(0)
+        };
+        for pair in it {
             if pair.as_rule() != Rule::path_separator {
                 pairs_buf.push(check!(
                     ident::parse_from_pair(pair, config),
@@ -83,7 +97,24 @@ impl CallPath {
         let suffix = pairs_buf.pop().unwrap();
         let prefixes = pairs_buf;
 
-        // TODO eventually we want to be able to call methods with colon-delineated syntax
-        ok(CallPath { prefixes, suffix }, warnings, errors)
+        ok(
+            CallPath {
+                prefixes,
+                suffix,
+                is_absolute,
+            },
+            warnings,
+            errors,
+        )
+    }
+
+    pub(crate) fn friendly_name(&self) -> String {
+        let mut buf = String::new();
+        for prefix in self.prefixes.iter() {
+            buf.push_str(prefix.as_str());
+            buf.push_str("::");
+        }
+        buf.push_str(self.suffix.as_str());
+        buf
     }
 }

sway-core/src/parse_tree/declaration/impl_trait.rs

@@ -51,7 +51,7 @@ impl ImplTrait {
         let impl_keyword = iter.next().unwrap();
         assert_eq!(impl_keyword.as_str(), "impl");
         let trait_name = iter.next().unwrap();
-        assert_eq!(trait_name.as_rule(), Rule::trait_name);
+        assert_eq!(trait_name.as_rule(), Rule::call_path);
         let trait_name = check!(
             CallPath::parse_from_pair(trait_name, config),
             return err(warnings, errors),

sway-core/src/parse_tree/declaration/struct.rs

@@ -86,6 +86,7 @@ impl StructDeclaration {
             span: name.as_span(),
             path,
         };
+
         let name = check!(
             ident::parse_from_pair(name, config),
             return err(warnings, errors),

sway-core/src/parse_tree/expression/method_name.rs

@@ -9,7 +9,6 @@ pub enum MethodName {
         call_path: CallPath,
         // if this is `None`, then use the first argument to determine the type
         type_name: Option<TypeInfo>,
-        is_absolute: bool,
     },
     /// Represents a method lookup that does not contain any types in the path
     FromModule { method_name: Ident },

sway-core/src/parse_tree/expression/mod.rs

@@ -67,7 +67,7 @@ pub enum Expression {
         span: Span,
     },
     StructExpression {
-        struct_name: Ident,
+        struct_name: CallPath,
         fields: Vec<StructExpressionField>,
         span: Span,
     },
@@ -218,9 +218,9 @@ impl Expression {
                         span: span.clone(),
                     }
                     .to_var_name(),
+                    is_absolute: true,
                 },
                 type_name: None,
-                is_absolute: true,
             },
             arguments,
             span,
@@ -236,9 +236,9 @@ impl Expression {
                         Ident::new_with_override("ops", span.clone()),
                     ],
                     suffix: op.to_var_name(),
+                    is_absolute: true,
                 },
                 type_name: None,
-                is_absolute: true,
             },
             arguments,
             span,
@@ -394,17 +394,13 @@ impl Expression {
                 };
                 let mut func_app_parts = expr.into_inner();
                 let first_part = func_app_parts.next().unwrap();
-                assert!(first_part.as_rule() == Rule::ident);
-                let suffix = check!(
-                    ident::parse_from_pair(first_part, config),
+                assert!(first_part.as_rule() == Rule::call_path);
+                let name = check!(
+                    CallPath::parse_from_pair(first_part, config),
                     return err(warnings, errors),
                     warnings,
                     errors
                 );
-                let name = CallPath {
-                    prefixes: vec![],
-                    suffix,
-                };
                 let (arguments, type_args) = {
                     let maybe_type_args = func_app_parts.next().unwrap();
                     match maybe_type_args.as_rule() {
@@ -531,7 +527,7 @@ impl Expression {
                 let mut expr_iter = expr.into_inner();
                 let struct_name = expr_iter.next().unwrap();
                 let struct_name = check!(
-                    ident::parse_from_pair(struct_name, config),
+                    CallPath::parse_from_pair(struct_name, config),
                     return err(warnings, errors),
                     warnings,
                     errors
@@ -744,16 +740,16 @@ impl Expression {
                         }
                     }
                     Rule::fully_qualified_method => {
-                        let mut path_parts_buf = vec![];
+                        let mut call_path = None;
                         let mut type_name = None;
                         let mut method_name = None;
                         let mut arguments = None;
                         for pair in pair.into_inner() {
                             match pair.as_rule() {
                                 Rule::path_separator => (),
-                                Rule::path_ident => {
-                                    path_parts_buf.push(check!(
-                                        ident::parse_from_pair(pair, config),
+                                Rule::call_path => {
+                                    call_path = Some(check!(
+                                        CallPath::parse_from_pair(pair, config),
                                         continue,
                                         warnings,
                                         errors
@@ -781,22 +777,48 @@ impl Expression {
                             errors
                         );
 
-                        // parse the method name into a call path
-                        let method_name = MethodName::FromType {
-                            call_path: CallPath {
-                                prefixes: path_parts_buf,
-                                suffix: check!(
-                                    ident::parse_from_pair(
-                                        method_name.expect("guaranteed by grammar"),
-                                        config
-                                    ),
-                                    return err(warnings, errors),
-                                    warnings,
-                                    errors
-                                ),
-                            },
-                            type_name: Some(type_name),
-                            is_absolute: false,
+                        let method_name = match call_path {
+                            Some(call_path) => {
+                                let mut call_path_buf = call_path.prefixes;
+                                call_path_buf.push(call_path.suffix);
+
+                                // parse the method name into a call path
+                                MethodName::FromType {
+                                    call_path: CallPath {
+                                        prefixes: call_path_buf,
+                                        suffix: check!(
+                                            ident::parse_from_pair(
+                                                method_name.expect("guaranteed by grammar"),
+                                                config
+                                            ),
+                                            return err(warnings, errors),
+                                            warnings,
+                                            errors
+                                        ),
+                                        is_absolute: call_path.is_absolute, //is_absolute: false,
+                                    },
+                                    type_name: Some(type_name),
+                                }
+                            }
+                            None => {
+                                // parse the method name into a call path
+                                MethodName::FromType {
+                                    call_path: CallPath {
+                                        prefixes: vec![],
+                                        suffix: check!(
+                                            ident::parse_from_pair(
+                                                method_name.expect("guaranteed by grammar"),
+                                                config
+                                            ),
+                                            return err(warnings, errors),
+                                            warnings,
+                                            errors
+                                        ),
+                                        is_absolute: false, //is_absolute: false,
+                                    },
+                                    type_name: Some(type_name),
+                                }
+                            }
                         };
 
                         let mut arguments_buf = vec![];

sway-core/src/parse_tree/expression/unary_op.rs

@@ -55,6 +55,7 @@ impl UnaryOp {
                     Ident::new_with_override("ops", op_span.clone()),
                 ],
                 suffix: Ident::new_with_override(self.to_var_name(), op_span),
+                is_absolute: false,
             },
             arguments: vec![arg],
             span,