[Feat] Add network.id and self.address opcodes

Cargo.toml

@@ -46,7 +46,7 @@ members = [
 [workspace.dependencies.snarkvm]
 #version = "0.16.19"
 git = "https://github.com/AleoHQ/snarkVM"
-rev = "2cbf34a"
+rev = "da3d78a"
 
 [lib]
 path = "leo/lib.rs"

compiler/ast/src/expressions/literal.rs

@@ -22,7 +22,7 @@ use super::*;
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum Literal {
  // todo: deserialize values here
- /// An address literal, e.g., `aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8s7pyjh9`.
+ /// An address literal, e.g., `aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8s7pyjh9` or `hello.aleo`.
  Address(String, #[serde(with = "leo_span::span_json")] Span, NodeID),
  /// A boolean literal, either `true` or `false`.
  Boolean(bool, #[serde(with = "leo_span::span_json")] Span, NodeID),

compiler/parser/src/parser/expression.rs

@@ -441,8 +441,8 @@ impl ParserContext<'_> {
 
  // Parses an external function call `credits.aleo/transfer()` or locator `token.aleo/accounts`.
  fn parse_external_resource(&mut self, expr: Expression, network_span: Span) -> Result<Expression> {
- // Eat an external function call.
- self.eat(&Token::Div); // todo: Make `/` a more general token.
+ // Parse `/`.
+ self.expect(&Token::Div)?;
 
  // Parse name.
  let name = self.expect_identifier()?;
@@ -507,8 +507,35 @@ impl ParserContext<'_> {
  } else if self.eat(&Token::Leo) {
  return Err(ParserError::only_aleo_external_calls(expr.span()).into());
  } else if self.eat(&Token::Aleo) {
- expr = self.parse_external_resource(expr, self.prev_token.span)?;
+ if self.token.token == Token::Div {
+ expr = self.parse_external_resource(expr, self.prev_token.span)?;
+ } else {
+ // Parse as address literal, e.g. `hello.aleo`.
+ if !matches!(expr, Expression::Identifier(_)) {
+ self.emit_err(ParserError::unexpected(expr.to_string(), "an identifier", expr.span()))
+ }
+
+ expr = Expression::Literal(Literal::Address(
+ format!("{}.aleo", expr),
+ expr.span(),
+ self.node_builder.next_id(),
+ ))
+ }
  } else {
+ // Parse instances of `self.address`.
+ if let Expression::Identifier(id) = expr {
+ if id.name == sym::SelfLower && self.token.token == Token::Address {
+ let span = self.expect(&Token::Address)?;
+ // Convert `self.address` to the current program name. TODO: Move this conversion to canonicalization pass when the new pass is added.
+ // Note that the unwrap is safe as in order to get to this stage of parsing a program name must have already been parsed.
+ return Ok(Expression::Literal(Literal::Address(
+ format!("{}.aleo", self.program_name.unwrap()),
+ expr.span() + span,
+ self.node_builder.next_id(),
+ )));
+ }
+ }
+
  // Parse identifier name.
  let name = self.expect_identifier()?;
 
@@ -769,6 +796,9 @@ impl ParserContext<'_> {
  Token::Future => {
  Expression::Identifier(Identifier { name: sym::Future, span, id: self.node_builder.next_id() })
  }
+ Token::Network => {
+ Expression::Identifier(Identifier { name: sym::network, span, id: self.node_builder.next_id() })
+ }
  t if crate::type_::TYPE_TOKENS.contains(&t) => Expression::Identifier(Identifier {
  name: t.keyword_to_symbol().unwrap(),
  span,

compiler/parser/src/tokenizer/token.rs

@@ -143,6 +143,7 @@ pub enum Token {
  Block,
  Eof,
  Leo,
+ Network,
 }
 
 /// Represents all valid Leo keyword tokens.
@@ -180,6 +181,7 @@ pub const KEYWORD_TOKENS: &[Token] = &[
  Token::Inline,
  Token::Let,
  Token::Mapping,
+ Token::Network,
  Token::Private,
  Token::Program,
  Token::Public,
@@ -237,6 +239,7 @@ impl Token {
  Token::Let => sym::Let,
  Token::Leo => sym::leo,
  Token::Mapping => sym::mapping,
+ Token::Network => sym::network,
  Token::Private => sym::private,
  Token::Program => sym::program,
  Token::Public => sym::public,
@@ -374,6 +377,7 @@ impl fmt::Display for Token {
  Block => write!(f, "block"),
  Leo => write!(f, "leo"),
  Eof => write!(f, "<eof>"),
+ Network => write!(f, "network"),
  }
  }
 }

compiler/passes/src/code_generation/visit_program.rs

@@ -182,6 +182,7 @@ impl<'a> CodeGenerator<'a> {
  // TODO: Figure out a better way to initialize.
  self.variable_mapping.insert(&sym::SelfLower, "self".to_string());
  self.variable_mapping.insert(&sym::block, "block".to_string());
+ self.variable_mapping.insert(&sym::network, "network".to_string());
  self.current_function = Some(function);
 
  // Construct the header of the function.

compiler/passes/src/flattening/flatten_statement.rs

@@ -273,7 +273,9 @@ impl StatementReconstructor for Flattener<'_> {
  let guard = self.construct_guard();
 
  match input.expression {
- Expression::Unit(_) | Expression::Identifier(_) => self.returns.push((guard, input)),
+ Expression::Unit(_) | Expression::Identifier(_) | Expression::Access(_) => {
+ self.returns.push((guard, input))
+ }
  _ => unreachable!("SSA guarantees that the expression is always an identifier or unit expression."),
  };
 

compiler/passes/src/type_checking/check_expressions.rs

@@ -202,22 +202,12 @@ impl<'a> ExpressionVisitor<'a> for TypeChecker<'a> {
  Expression::Identifier(identifier) if identifier.name == sym::SelfLower => match access.name.name {
  sym::caller => {
  // Check that the operation is not invoked in a `finalize` block.
- if self.scope_state.variant == Some(Variant::AsyncFunction) {
- self.handler.emit_err(TypeCheckerError::invalid_operation_inside_finalize(
- "self.caller",
- access.name.span(),
- ))
- }
+ self.check_access_allowed("self.caller", false, access.name.span());
  return Some(Type::Address);
  }
  sym::signer => {
  // Check that operation is not invoked in a `finalize` block.
- if self.scope_state.variant == Some(Variant::AsyncFunction) {
- self.handler.emit_err(TypeCheckerError::invalid_operation_inside_finalize(
- "self.signer",
- access.name.span(),
- ))
- }
+ self.check_access_allowed("self.signer", false, access.name.span());
  return Some(Type::Address);
  }
  _ => {
@@ -228,18 +218,24 @@ impl<'a> ExpressionVisitor<'a> for TypeChecker<'a> {
  Expression::Identifier(identifier) if identifier.name == sym::block => match access.name.name {
  sym::height => {
  // Check that the operation is invoked in a `finalize` block.
- if self.scope_state.variant != Some(Variant::AsyncFunction) {
- self.handler.emit_err(TypeCheckerError::invalid_operation_outside_finalize(
- "block.height",
- access.name.span(),
- ))
- }
+ self.check_access_allowed("block.height", true, access.name.span());
  return Some(Type::Integer(IntegerType::U32));
  }
  _ => {
  self.emit_err(TypeCheckerError::invalid_block_access(access.name.span()));
  }
  },
+ // If the access expression is of the form `network.<name>`, then check that the <name> is valid.
+ Expression::Identifier(identifier) if identifier.name == sym::network => match access.name.name {
+ sym::id => {
+ // Check that the operation is not invoked outside a `finalize` block.
+ self.check_access_allowed("network.id", true, access.name.span());
+ return Some(Type::Integer(IntegerType::U16));
+ }
+ _ => {
+ self.emit_err(TypeCheckerError::invalid_block_access(access.name.span()));
+ }
+ },
  _ => {
  // Check that the type of `inner` in `inner.name` is a struct.
  match self.visit_expression(&access.inner, &None) {

compiler/passes/src/type_checking/checker.rs

@@ -449,7 +449,7 @@ impl<'a> TypeChecker<'a> {
  /// Emits an error if the correct number of arguments are not provided.
  /// Emits an error if the arguments are not of the correct type.
  pub(crate) fn check_core_function_call(
- &self,
+ &mut self,
  core_function: CoreFunction,
  arguments: &[(Option<Type>, Span)],
  function_span: Span,
@@ -978,10 +978,7 @@ impl<'a> TypeChecker<'a> {
  }
  CoreFunction::MappingGet => {
  // Check that the operation is invoked in a `finalize` block.
- if self.scope_state.variant != Some(Variant::AsyncFunction) {
- self.handler
- .emit_err(TypeCheckerError::invalid_operation_outside_finalize("Mapping::get", function_span))
- }
+ self.check_access_allowed("Mapping::get", true, function_span);
  // Check that the first argument is a mapping.
  if let Some(mapping_type) = self.assert_mapping_type(&arguments[0].0, arguments[0].1) {
  // Check that the second argument matches the key type of the mapping.
@@ -994,12 +991,7 @@ impl<'a> TypeChecker<'a> {
  }
  CoreFunction::MappingGetOrUse => {
  // Check that the operation is invoked in a `finalize` block.
- if self.scope_state.variant != Some(Variant::AsyncFunction) {
- self.handler.emit_err(TypeCheckerError::invalid_operation_outside_finalize(
- "Mapping::get_or",
- function_span,
- ))
- }
+ self.check_access_allowed("Mapping::get_or", true, function_span);
  // Check that the first argument is a mapping.
  if let Some(mapping_type) = self.assert_mapping_type(&arguments[0].0, arguments[0].1) {
  // Check that the second argument matches the key type of the mapping.
@@ -1014,10 +1006,7 @@ impl<'a> TypeChecker<'a> {
  }
  CoreFunction::MappingSet => {
  // Check that the operation is invoked in a `finalize` block.
- if self.scope_state.variant != Some(Variant::AsyncFunction) {
- self.handler
- .emit_err(TypeCheckerError::invalid_operation_outside_finalize("Mapping::set", function_span))
- }
+ self.check_access_allowed("Mapping::set", true, function_span);
  // Check that the first argument is a mapping.
  if let Some(mapping_type) = self.assert_mapping_type(&arguments[0].0, arguments[0].1) {
  // Cannot modify external mappings.
@@ -1036,12 +1025,7 @@ impl<'a> TypeChecker<'a> {
  }
  CoreFunction::MappingRemove => {
  // Check that the operation is invoked in a `finalize` block.
- if self.scope_state.variant != Some(Variant::AsyncFunction) {
- self.handler.emit_err(TypeCheckerError::invalid_operation_outside_finalize(
- "Mapping::remove",
- function_span,
- ))
- }
+ self.check_access_allowed("Mapping::remove", true, function_span);
  // Check that the first argument is a mapping.
  if let Some(mapping_type) = self.assert_mapping_type(&arguments[0].0, arguments[0].1) {
  // Cannot modify external mappings.
@@ -1059,12 +1043,7 @@ impl<'a> TypeChecker<'a> {
  }
  CoreFunction::MappingContains => {
  // Check that the operation is invoked in a `finalize` block.
- if self.scope_state.variant != Some(Variant::AsyncFunction) {
- self.handler.emit_err(TypeCheckerError::invalid_operation_outside_finalize(
- "Mapping::contains",
- function_span,
- ))
- }
+ self.check_access_allowed("Mapping::contains", true, function_span);
  // Check that the first argument is a mapping.
  if let Some(mapping_type) = self.assert_mapping_type(&arguments[0].0, arguments[0].1) {
  // Check that the second argument matches the key type of the mapping.
@@ -1506,6 +1485,16 @@ impl<'a> TypeChecker<'a> {
  self.handler.emit_err(err);
  }
  }
+
+ // Checks if the access operation is valid inside the current function variant.
+ pub(crate) fn check_access_allowed(&mut self, name: &str, finalize_op: bool, span: Span) {
+ // Check that the function context matches.
+ if self.scope_state.variant == Some(Variant::AsyncFunction) && !finalize_op {
+ self.handler.emit_err(TypeCheckerError::invalid_operation_inside_finalize(name, span))
+ } else if self.scope_state.variant != Some(Variant::AsyncFunction) && finalize_op {
+ self.handler.emit_err(TypeCheckerError::invalid_operation_outside_finalize(name, span))
+ }
+ }
 }
 
 fn types_to_string(types: &[Type]) -> String {

compiler/span/src/symbol.rs

@@ -272,6 +272,8 @@ symbols! {
  stub,
  block,
  height,
+ network,
+ id,
 }
 
 /// An interned string.

tests/expectations/compiler/address/special_address.out

@@ -0,0 +1,18 @@
+---
+namespace: Compile
+expectation: Pass
+outputs:
+ - - compile:
+ - initial_symbol_table: f159adcd5ea24c580a6b8535b217667a40173809e5802a0b03db3dc5b9bec9aa
+ type_checked_symbol_table: 9fd0ee7288d5151305f4cd3820594bd9db7accb589bc936e186709af1df6de21
+ unrolled_symbol_table: 9fd0ee7288d5151305f4cd3820594bd9db7accb589bc936e186709af1df6de21
+ initial_ast: 21db64864f84959ad71dace62a2487285c3b6bb74818536b83a54b63a2bd8d82
+ unrolled_ast: 21db64864f84959ad71dace62a2487285c3b6bb74818536b83a54b63a2bd8d82
+ ssa_ast: d4e2a516deaa30f8663bb3cd1501c52e3cc781b330dbb149ee3bad0692a8cb59
+ flattened_ast: 175fbd23f91421e3d47440c8a7e00fb9e3a2bef1147e061cd8a3f2bd0c978098
+ destructured_ast: a23caa23b3ac10d6c2a1b119af502a9ec4380cf521eb65da2c9e2a5f19d44172
+ inlined_ast: a23caa23b3ac10d6c2a1b119af502a9ec4380cf521eb65da2c9e2a5f19d44172
+ dce_ast: a23caa23b3ac10d6c2a1b119af502a9ec4380cf521eb65da2c9e2a5f19d44172
+ bytecode: d9e6c28f9e5527abe9cdb07b9d35375901446415f5d645b0363597200ee45be7
+ errors: ""
+ warnings: ""

tests/expectations/compiler/expression/network_id.out

@@ -0,0 +1,18 @@
+---
+namespace: Compile
+expectation: Pass
+outputs:
+ - - compile:
+ - initial_symbol_table: 02b83350abcecb36109bf268cf52b9fc867ab1893c49badf31ff527156528943
+ type_checked_symbol_table: 1ace971bd20adb9ce07f802070f05c51733af791ef32c7b1130d4a4b2182768d
+ unrolled_symbol_table: 1ace971bd20adb9ce07f802070f05c51733af791ef32c7b1130d4a4b2182768d
+ initial_ast: 6dc0a710ab752f571f4dae9fdb172a7fa1c43e3af3858cbc8cf96c5d510a0c3a
+ unrolled_ast: 6dc0a710ab752f571f4dae9fdb172a7fa1c43e3af3858cbc8cf96c5d510a0c3a
+ ssa_ast: e09d30595377e81788433b702f76f1338ff4bb720f8564e2560e5f78ebd18bc0
+ flattened_ast: 16df732ae63243e249201817b30ae02b8a190072d39894648607970eb2b09192
+ destructured_ast: b2f615fbb0825b50c961b4014e2e2d60117b543cab0d2e1acd4f3237c878e95e
+ inlined_ast: d3f7291df3faf6f8a4893b91133fe183d44c35f3d9c4b9d270d71f943482f965
+ dce_ast: d3f7291df3faf6f8a4893b91133fe183d44c35f3d9c4b9d270d71f943482f965
+ bytecode: ae04a04e7ffb01dfdd0ae0249f31649302bc120ea928c5ace16bc0879140e1f9
+ errors: ""
+ warnings: ""