Following changes have been made,

czgdp1807 · czgdp1807 · commit eb8017e9bc94 · 2023-03-26T16:35:28.000+05:30
1. Only those variables which are constant and have a compile time initialisation expression will have non-nullptr values for m_symbolic_value and m_value
2. Rest all will be converted to assignment statements.
diff --git a/integration_tests/nrp/nr.py b/integration_tests/nrp/nr.py
@@ -1,4 +1,4 @@
-from ltypes import i32, f64
+from lpython import i32, f64
 
 
 def func(x: f64, c: f64) -> f64:
diff --git a/integration_tests/test_package_01.py b/integration_tests/test_package_01.py
@@ -1,5 +1,5 @@
 from nrp import newton_raphson
-from ltypes import f64, i32
+from lpython import f64, i32
 
 
 def check():
diff --git a/integration_tests/variable_decl_01.py b/integration_tests/variable_decl_01.py
@@ -1,8 +1,8 @@
-from lpython import i32, i64
+from lpython import i32, i64, Const
 from numpy import empty, int64
 
 def f(n: i32, m: i32):
-    l: i32 = 2
+    l: Const[i32] = 2
     a: i64[n, m, l] = empty((n, m, l), dtype=int64)
     i: i32; j: i32; k: i32;
     for i in range(n):
diff --git a/src/libasr/asr_utils.cpp b/src/libasr/asr_utils.cpp
@@ -963,8 +963,8 @@ ASR::asr_t* make_Cast_t_value(Allocator &al, const Location &a_loc,
                         double_value, 0, a_type));
         } else if (a_kind == ASR::cast_kindType::IntegerToReal) {
             // TODO: Clashes with the pow functions
-            // int64_t value = ASR::down_cast<ASR::ConstantInteger_t>(ASRUtils::expr_value(a_arg))->m_n;
-            // value = ASR::down_cast<ASR::expr_t>(ASR::make_ConstantReal_t(al, a_loc, (double)v, a_type));
+            int64_t int_value = ASR::down_cast<ASR::IntegerConstant_t>(ASRUtils::expr_value(a_arg))->m_n;
+            value = ASR::down_cast<ASR::expr_t>(ASR::make_RealConstant_t(al, a_loc, (double)int_value, a_type));
         } else if (a_kind == ASR::cast_kindType::IntegerToComplex) {
             int64_t int_value = ASR::down_cast<ASR::IntegerConstant_t>(
                                 ASRUtils::expr_value(a_arg))->m_n;
diff --git a/src/libasr/asr_verify.cpp b/src/libasr/asr_verify.cpp
@@ -516,6 +516,15 @@ class VerifyVisitor : public BaseWalkVisitor<VerifyVisitor>
             "Variable::m_parent_symtab must be present in the ASR ("
                 + std::string(x.m_name) + ")");
 
+        if( symtab->parent == nullptr ) {
+            // For nowRestrict this check only to variables which are present
+            // inside symbols which have a body.
+            require( (x.m_symbolic_value == nullptr && x.m_value == nullptr) ||
+                     (x.m_symbolic_value != nullptr && x.m_value != nullptr),
+                    "Initialisation of " + std::string(x.m_name) +
+                    " must reduce to a compile time constant.");
+        }
+
         if (x.m_symbolic_value)
             visit_expr(*x.m_symbolic_value);
         visit_ttype(*x.m_type);
diff --git a/src/libasr/pass/inline_function_calls.cpp b/src/libasr/pass/inline_function_calls.cpp
@@ -294,18 +294,22 @@ class InlineFunctionCallVisitor : public PassUtils::PassVisitor<InlineFunctionCa
                     break;
                 }
                 ASR::ttype_t* local_var_type = func_var->m_type;
+                if( ASR::is_a<ASR::Const_t>(*local_var_type) ) {
+                    local_var_type = ASR::down_cast<ASR::Const_t>(local_var_type)->m_type;
+                }
+                LCOMPILERS_ASSERT(!ASR::is_a<ASR::Const_t>(*local_var_type));
                 ASR::symbol_t* local_var = (ASR::symbol_t*) ASR::make_Variable_t(
-                                                al, func_var->base.base.loc, current_scope,
-                                                s2c(al, local_var_name), nullptr, 0, ASR::intentType::Local,
-                                                nullptr, nullptr, ASR::storage_typeType::Default,
-                                                local_var_type, ASR::abiType::Source, ASR::accessType::Public,
-                                                ASR::presenceType::Required, false);
+                        al, func_var->base.base.loc, current_scope,
+                        s2c(al, local_var_name), nullptr, 0, ASR::intentType::Local,
+                        nullptr, nullptr, ASR::storage_typeType::Default,
+                        local_var_type, ASR::abiType::Source, ASR::accessType::Public,
+                        ASR::presenceType::Required, false);
                 current_scope->add_symbol(local_var_name, local_var);
                 arg2value[func_var_name] = local_var;
-                if( m_symbolic_value && !ASR::is_a<ASR::Const_t>(*local_var_type) ) {
+                if( m_symbolic_value ) {
                     exprs_to_be_visited.push_back(std::make_pair(m_symbolic_value, local_var));
                 }
-                if( m_value && !ASR::is_a<ASR::Const_t>(*local_var_type) ) {
+                if( m_value ) {
                     exprs_to_be_visited.push_back(std::make_pair(m_value, local_var));
                 }
             }
diff --git a/src/lpython/semantics/python_ast_to_asr.cpp b/src/lpython/semantics/python_ast_to_asr.cpp
@@ -1376,6 +1376,20 @@ class CommonVisitor : public AST::BaseVisitor<Struct> {
         return t;
     }
 
+    bool contains_local_variable(ASR::expr_t* value) {
+        if( ASR::is_a<ASR::Var_t>(*value) ) {
+            ASR::Var_t* var_value = ASR::down_cast<ASR::Var_t>(value);
+            ASR::symbol_t* var_value_sym = var_value->m_v;
+            ASR::Variable_t* var_value_variable = ASR::down_cast<ASR::Variable_t>(
+                ASRUtils::symbol_get_past_external(var_value_sym));
+            return var_value_variable->m_intent == ASR::intentType::Local;
+        }
+
+        // TODO: Let any other expression pass through
+        // Will be handled later
+        return false;
+    }
+
     void fill_dims_for_asr_type(Vec<ASR::dimension_t>& dims,
                                 ASR::expr_t* value, const Location& loc) {
         ASR::dimension_t dim;
@@ -1388,8 +1402,13 @@ class CommonVisitor : public AST::BaseVisitor<Struct> {
             ASR::expr_t* zero = ASRUtils::EXPR(ASR::make_IntegerConstant_t(al, loc, 0, itype));
             ASR::expr_t* comptime_val = nullptr;
             int64_t value_int = -1;
-            ASRUtils::extract_value(ASRUtils::expr_value(value), value_int);
-            if( value_int != -1 ) {
+            if( !ASRUtils::extract_value(ASRUtils::expr_value(value), value_int) &&
+                contains_local_variable(value) ) {
+                throw SemanticError("Only those local variables which can be reduced to compile "
+                                    "time constant should be used in dimensions of an array.",
+                                    value->base.loc);
+            }
+            if (value_int != -1) {
                 comptime_val = ASRUtils::EXPR(ASR::make_IntegerConstant_t(al, loc, value_int - 1, itype));
             }
             dim.m_start = zero;
@@ -2184,12 +2203,20 @@ class CommonVisitor : public AST::BaseVisitor<Struct> {
     }
 
     void create_add_variable_to_scope(std::string& var_name, ASR::expr_t* init_expr,
-        ASR::expr_t* value, ASR::ttype_t* type,
-        const Location& loc, ASR::abiType abi) {
-        if( ASR::is_a<ASR::Const_t>(*type) && !init_expr ) {
+        ASR::ttype_t* type, const Location& loc, ASR::abiType abi) {
+
+        ASR::expr_t* value = nullptr;
+        if( init_expr ) {
+            value = ASRUtils::expr_value(init_expr);
+        }
+        bool is_runtime_expression = !ASRUtils::is_value_constant(value);
+        bool is_variable_const = ASR::is_a<ASR::Const_t>(*type);
+
+        if( is_variable_const && !init_expr ) {
             throw SemanticError("Constant variable " + var_name +
                 " is not initialised at declaration.", loc);
         }
+
         ASR::intentType s_intent = ASRUtils::intent_local;
         ASR::storage_typeType storage_type =
                 ASR::storage_typeType::Default;
@@ -2210,24 +2237,30 @@ class CommonVisitor : public AST::BaseVisitor<Struct> {
                 current_procedure_abi_type, s_access, s_presence,
                 value_attr);
         ASR::symbol_t* v_sym = ASR::down_cast<ASR::symbol_t>(v);
+        ASR::Variable_t* v_variable = ASR::down_cast<ASR::Variable_t>(v_sym);
 
-        if( init_expr && current_body) {
+        if( init_expr && current_body &&
+            (is_runtime_expression || !is_variable_const)) {
             ASR::expr_t* v_expr = ASRUtils::EXPR(ASR::make_Var_t(al, loc, v_sym));
             cast_helper(v_expr, init_expr, true);
             ASR::asr_t* assign = ASR::make_Assignment_t(al, loc, v_expr,
                                                         init_expr, nullptr);
             current_body->push_back(al, ASRUtils::STMT(assign));
-            ASR::Variable_t* v_variable = ASR::down_cast<ASR::Variable_t>(v_sym);
-            if( !ASR::is_a<ASR::Const_t>(*type) &&
-                ASRUtils::is_aggregate_type(type) ) {
-                v_variable->m_symbolic_value = nullptr;
-                v_variable->m_value = nullptr;
-                Vec<char*> variable_dependencies_vec;
-                variable_dependencies_vec.reserve(al, 1);
-                ASRUtils::collect_variable_dependencies(al, variable_dependencies_vec, type);
-                v_variable->m_dependencies = variable_dependencies_vec.p;
-                v_variable->n_dependencies = variable_dependencies_vec.size();
-            }
+
+            v_variable->m_symbolic_value = nullptr;
+            v_variable->m_value = nullptr;
+            Vec<char*> variable_dependencies_vec;
+            variable_dependencies_vec.reserve(al, 1);
+            ASRUtils::collect_variable_dependencies(al, variable_dependencies_vec, type);
+            v_variable->m_dependencies = variable_dependencies_vec.p;
+            v_variable->n_dependencies = variable_dependencies_vec.size();
+        }
+
+        // Restrict this check only to symbols which have a body.
+        if( !((v_variable->m_symbolic_value == nullptr && v_variable->m_value == nullptr) ||
+              (v_variable->m_symbolic_value != nullptr && v_variable->m_value != nullptr)) &&
+              current_body ) {
+            throw SemanticError("Initialisation of " + var_name + " must reduce to a compile time constant.", loc);
         }
         current_scope->add_symbol(var_name, v_sym);
     }
@@ -2275,7 +2308,7 @@ class CommonVisitor : public AST::BaseVisitor<Struct> {
                 this->visit_expr(*x.m_value);
             }
             if( is_c_p_pointer_call ) {
-                create_add_variable_to_scope(var_name, nullptr, nullptr, type,
+                create_add_variable_to_scope(var_name, nullptr, type,
                     x.base.base.loc, abi);
                 AST::Call_t* c_p_pointer_call = AST::down_cast<AST::Call_t>(x.m_value);
                 AST::expr_t* cptr = c_p_pointer_call->m_args[0];
@@ -2305,17 +2338,13 @@ class CommonVisitor : public AST::BaseVisitor<Struct> {
                     throw SemanticAbort();
                 }
                 init_expr = value;
-                value = nullptr;
-                if( ASR::is_a<ASR::Const_t>(*type) ) {
-                    value = ASRUtils::expr_value(init_expr);
-                }
             }
         } else {
             cast_helper(type, init_expr, init_expr->base.loc);
         }
 
         if( !is_c_p_pointer_call ) {
-            create_add_variable_to_scope(var_name, init_expr, value, type,
+            create_add_variable_to_scope(var_name, init_expr, type,
                 x.base.base.loc, abi);
         }
 
@@ -5685,7 +5714,7 @@ class BodyVisitor : public CommonVisitor<BodyVisitor> {
             fn_args.push_back(al, sub);
         } else if (attr_name == "endswith") {
             /*
-                str.endswith(suffix)     ---->  
+                str.endswith(suffix)     ---->
                 Return True if the string ends with the specified suffix, otherwise return False.
 
                 arg_sub: Substring argument provided inside endswith() function
@@ -5907,8 +5936,8 @@ class BodyVisitor : public CommonVisitor<BodyVisitor> {
             }
             return;
         } else if (attr_name == "endswith") {
-            /* 
-                str.endswith(suffix)     ---->  
+            /*
+                str.endswith(suffix)     ---->
                 Return True if the string ends with the specified suffix, otherwise return False.
             */
 
@@ -5921,23 +5950,23 @@ class BodyVisitor : public CommonVisitor<BodyVisitor> {
             if (!ASRUtils::is_character(*arg_suffix_type)) {
                 throw SemanticError("str.endswith() takes one arguments of type: str", arg_suffix->base.loc);
             }
-            
+
             if (ASRUtils::expr_value(arg_suffix) != nullptr) {
                 /*
                     Invoked when Suffix argument is provided as a constant string
                 */
                 ASR::StringConstant_t* suffix_constant = ASR::down_cast<ASR::StringConstant_t>(arg_suffix);
                 std::string suffix = suffix_constant->m_s;
-                
+
                 bool res = true;
-                if (suffix.size() > s_var.size()) 
+                if (suffix.size() > s_var.size())
                     res = false;
-                else 
+                else
                     res = std::equal(suffix.rbegin(), suffix.rend(), s_var.rbegin());
-                
-                tmp = ASR::make_LogicalConstant_t(al, loc, res, 
+
+                tmp = ASR::make_LogicalConstant_t(al, loc, res,
                     ASRUtils::TYPE(ASR::make_Logical_t(al, loc, 4, nullptr, 0)));
-    
+
             } else {
                 /*
                     Invoked when Suffix argument is provided as a variable
diff --git a/src/lpython/semantics/python_intrinsic_eval.h b/src/lpython/semantics/python_intrinsic_eval.h
@@ -110,6 +110,12 @@ struct IntrinsicNodeHandler {
         } else if (ASRUtils::is_integer(*type)) {
             // int() returns a 64-bit integer
             if (ASRUtils::extract_kind_from_ttype_t(type) != 8) {
+                if (ASRUtils::expr_value(arg) != nullptr) {
+                    int64_t ival = ASR::down_cast<ASR::IntegerConstant_t>(
+                                            ASRUtils::expr_value(arg))->m_n;
+                    value =  ASR::down_cast<ASR::expr_t>(make_IntegerConstant_t(al,
+                                    loc, ival, to_type));
+                }
                 return (ASR::asr_t *)ASR::down_cast<ASR::expr_t>(ASR::make_Cast_t(
                     al, loc, arg, ASR::cast_kindType::IntegerToInteger,
                     to_type, value));

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-from ltypes import i32, f64`
	`1`	`+from lpython import i32, f64`
`2`	`2`
`3`	`3`
`4`	`4`	`def func(x: f64, c: f64) -> f64:`