Add support for dict methods with Const

integration_tests/test_dict_const.py

@@ -0,0 +1,18 @@
+from lpython import i32, f64, str, dict, Const
+
+
+def test_dict_const():
+ d_int: Const[dict[str, i32]] = {"a": 1, "b": 2, "c": 3}
+
+ assert d_int.get("a") == 1
+ assert d_int.keys() == ["c", "a", "b"]
+ assert d_int.values() == [3, 1, 2]
+
+ d_float: Const[dict[str, f64]] = {"a": 1.0, "b": 2.0, "c": 3.0}
+
+ assert d_float.get("a") == 1.0
+ assert d_float.keys() == ["c", "a", "b"]
+ assert d_float.values() == [3.0, 1.0, 2.0]
+
+
+test_dict_const()

src/libasr/codegen/asr_to_llvm.cpp

@@ -1523,8 +1523,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
  }
 
  void visit_ListItem(const ASR::ListItem_t& x) {
- ASR::ttype_t* el_type = ASRUtils::get_contained_type(
- ASRUtils::expr_type(x.m_a));
+ ASR::ttype_t *el_type = ASRUtils::get_contained_type(ASRUtils::expr_type(x.m_a));
  int64_t ptr_loads_copy = ptr_loads;
  ptr_loads = 0;
  this->visit_expr(*x.m_a);
@@ -1540,8 +1539,8 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
  }
 
  void visit_DictItem(const ASR::DictItem_t& x) {
- ASR::Dict_t* dict_type = ASR::down_cast<ASR::Dict_t>(
- ASRUtils::expr_type(x.m_a));
+ ASR::Dict_t *dict_type = ASR::down_cast<ASR::Dict_t>(ASRUtils::type_get_past_const(ASRUtils::expr_type(x.m_a)));
+
  int64_t ptr_loads_copy = ptr_loads;
  ptr_loads = 0;
  this->visit_expr(*x.m_a);
@@ -1845,8 +1844,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
  }
 
  void generate_DictElems(ASR::expr_t* m_arg, bool key_or_value) {
- ASR::Dict_t* dict_type = ASR::down_cast<ASR::Dict_t>(
- ASRUtils::expr_type(m_arg));
+ ASR::Dict_t *dict_type = ASR::down_cast<ASR::Dict_t>(ASRUtils::type_get_past_const(ASRUtils::expr_type(m_arg)));
  ASR::ttype_t* el_type = key_or_value == 0 ?
  dict_type->m_key_type : dict_type->m_value_type;
 

src/libasr/pass/intrinsic_function_registry.h

@@ -2744,14 +2744,15 @@ namespace DictKeys {
 static inline void verify_args(const ASR::IntrinsicScalarFunction_t& x, diag::Diagnostics& diagnostics) {
  ASRUtils::require_impl(x.n_args == 1, "Call to dict.keys must have no argument",
  x.base.base.loc, diagnostics);
- ASRUtils::require_impl(ASR::is_a<ASR::Dict_t>(*ASRUtils::expr_type(x.m_args[0])),
- "Argument to dict.keys must be of dict type",
- x.base.base.loc, diagnostics);
+ ASR::ttype_t *dict_type = ASRUtils::type_get_past_const(ASRUtils::expr_type(x.m_args[0]));
+ ASRUtils::require_impl(ASR::is_a<ASR::Dict_t>(*dict_type),
+ "Argument to dict.keys must be of dict type",
+ x.base.base.loc, diagnostics);
  ASRUtils::require_impl(ASR::is_a<ASR::List_t>(*x.m_type) &&
- ASRUtils::check_equal_type(ASRUtils::get_contained_type(x.m_type),
- ASRUtils::get_contained_type(ASRUtils::expr_type(x.m_args[0]), 0)),
- "Return type of dict.keys must be of list of dict key element type",
- x.base.base.loc, diagnostics);
+  ASRUtils::check_equal_type(ASRUtils::get_contained_type(x.m_type),
+  ASR::down_cast<ASR::Dict_t>(dict_type)->m_key_type),
+  "Return type of dict.keys must be of list of dict key element type",
+  x.base.base.loc, diagnostics);
 }
 
 static inline ASR::expr_t *eval_dict_keys(Allocator &/*al*/,
@@ -2766,9 +2767,8 @@ static inline ASR::asr_t* create_DictKeys(Allocator& al, const Location& loc,
  if (args.size() != 1) {
  err("Call to dict.keys must have no argument", loc);
  }
-
  ASR::expr_t* dict_expr = args[0];
- ASR::ttype_t *type = ASRUtils::expr_type(dict_expr);
+ ASR::ttype_t *type = ASRUtils::type_get_past_const(ASRUtils::expr_type(dict_expr));
  ASR::ttype_t *dict_keys_type = ASR::down_cast<ASR::Dict_t>(type)->m_key_type;
 
  Vec<ASR::expr_t*> arg_values;
@@ -2790,14 +2790,17 @@ namespace DictValues {
 static inline void verify_args(const ASR::IntrinsicScalarFunction_t& x, diag::Diagnostics& diagnostics) {
  ASRUtils::require_impl(x.n_args == 1, "Call to dict.values must have no argument",
  x.base.base.loc, diagnostics);
- ASRUtils::require_impl(ASR::is_a<ASR::Dict_t>(*ASRUtils::expr_type(x.m_args[0])),
+ ASR::ttype_t *dict_type = ASR::is_a<ASR::Const_t>(*ASRUtils::expr_type(x.m_args[0]))
+ ? ASRUtils::type_get_past_const(ASRUtils::expr_type(x.m_args[0]))
+ : ASRUtils::expr_type(x.m_args[0]);
+ ASRUtils::require_impl(ASR::is_a<ASR::Dict_t>(*dict_type),
  "Argument to dict.values must be of dict type",
  x.base.base.loc, diagnostics);
  ASRUtils::require_impl(ASR::is_a<ASR::List_t>(*x.m_type) &&
- ASRUtils::check_equal_type(ASRUtils::get_contained_type(x.m_type),
- ASRUtils::get_contained_type(ASRUtils::expr_type(x.m_args[0]), 1)),
- "Return type of dict.values must be of list of dict value element type",
- x.base.base.loc, diagnostics);
+  ASRUtils::check_equal_type(ASRUtils::get_contained_type(x.m_type),
+  ASRUtils::get_contained_type(ASR::down_cast<ASR::Dict_t>(dict_type)->m_value_type, 1)),
+  "Return type of dict.values must be of list of dict value element type",
+  x.base.base.loc, diagnostics);
 }
 
 static inline ASR::expr_t *eval_dict_values(Allocator &/*al*/,
@@ -2814,7 +2817,7 @@ static inline ASR::asr_t* create_DictValues(Allocator& al, const Location& loc,
  }
 
  ASR::expr_t* dict_expr = args[0];
- ASR::ttype_t *type = ASRUtils::expr_type(dict_expr);
+ ASR::ttype_t *type = ASRUtils::type_get_past_const(ASRUtils::expr_type(dict_expr));
  ASR::ttype_t *dict_values_type = ASR::down_cast<ASR::Dict_t>(type)->m_value_type;
 
  Vec<ASR::expr_t*> arg_values;

src/lpython/semantics/python_attribute_eval.h

@@ -68,7 +68,7 @@ struct AttributeHandler {
  ASR::asr_t* get_attribute(ASR::expr_t *e, std::string attr_name,
  Allocator &al, const Location &loc, Vec<ASR::expr_t*> &args, diag::Diagnostics &diag) {
  ASR::ttype_t *type = ASRUtils::expr_type(e);
- std::string class_name = get_type_name(type);
+ std::string class_name = ASR::is_a<ASR::Const_t>(*type) ? "dict" : get_type_name(type);
  if (class_name == "") {
  throw SemanticError("Type name is not implemented yet.", loc);
  }
@@ -331,7 +331,7 @@ struct AttributeHandler {
  throw SemanticError("'get' takes atleast 1 and atmost 2 arguments",
  loc);
  }
- ASR::ttype_t *type = ASRUtils::expr_type(s);
+ ASR::ttype_t *type = ASRUtils::type_get_past_const(ASRUtils::expr_type(s));
  ASR::ttype_t *key_type = ASR::down_cast<ASR::Dict_t>(type)->m_key_type;
  ASR::ttype_t *value_type = ASR::down_cast<ASR::Dict_t>(type)->m_value_type;
  if (args.size() == 2) {
@@ -366,6 +366,9 @@ struct AttributeHandler {
 
  static ASR::asr_t* eval_dict_pop(ASR::expr_t *s, Allocator &al, const Location &loc,
  Vec<ASR::expr_t*> &args, diag::Diagnostics &diag) {
+ if (ASR::is_a<ASR::Const_t>(*ASRUtils::expr_type(s))) {
+ throw SemanticError("cannot pop elements from a const dict", loc);
+ }
  if (args.size() != 1) {
  throw SemanticError("'pop' takes only one argument for now", loc);
  }

tests/errors/test_dict_const.py

@@ -0,0 +1,7 @@
+from lpython import i32, f64, str, dict, Const
+
+
+def test_dict_const():
+ d: Const[dict[str, i32]] = {"a": 1, "b": 2, "c": 3}
+ print(d.pop("a"))
+ i: i32 = d.pop("a")