Instead of offsetting indices, set dimensions correctly in variable type

[czgdp1807]

lpython/src/lpython/semantics/python_ast_to_asr.cpp

Lines 887 to 896 in 4591db8

	ASR::expr_t *index_add_one(const Location &loc, ASR::expr_t *idx) {
	// Add 1 to the index `idx`, assumes `idx` is of type Integer 4
	ASR::expr_t *comptime_value = nullptr;
	ASR::ttype_t *a_type = ASRUtils::TYPE(ASR::make_Integer_t(al, loc,
	4, nullptr, 0));
	ASR::expr_t *constant_one = ASR::down_cast<ASR::expr_t>(ASR::make_IntegerConstant_t(
	al, loc, 1, a_type));
	return ASRUtils::EXPR(ASR::make_IntegerBinOp_t(al, loc, idx,
	ASR::binopType::Add, constant_one, a_type, comptime_value));
	}

lpython/src/lpython/semantics/python_ast_to_asr.cpp

Lines 866 to 870 in 4591db8

	if (ASR::is_a<ASR::IntegerConstant_t>(*value) || ASR::is_a<ASR::Var_t>(*value)) {
	ASR::ttype_t *itype = ASRUtils::TYPE(ASR::make_Integer_t(al, loc,
	4, nullptr, 0));
	dim.m_start = ASR::down_cast<ASR::expr_t>(ASR::make_IntegerConstant_t(al, loc, 1, itype));
	dim.m_end = value;

The above code is hackish and it becomes to keep track whether to offset the index by 1 in an optimisation pass or not. The reason of confusion is,

1. We are setting lower bound as 1 and upper bound as size in both Python and Fortran.
2. We offsetting indices by 1 only in Python.
3. We only have ASR while performing an optimisation pass. In Python we set lower and upper bounds same as Fortran but we offset index by 1 only in Python. Hence no clear differences between the two.

I suggest doing the following,

1. Set lower bound as 0 and upper bound as size - 1 in Python. In Fortran its provided by the user and default setting in LFortran is correct.
2. Don't offset indices by 1 in any LCompiler.
3. In an optimisation pass set the bounds of the loop (which we are creating manually in an optimisation pass) always to 0 + lower_bound(dimension) and size - 1 + lower_bound(dimension). In Python lower_bound(dimension) is always 0, so no worries. In Fortran lower_bound(dimension) is by default 1 so loop bounds will transform to 1 and size automatically.

I discovered this problem while working on #675 and I can fix it in #675 itself.

@certik Please let me know what you think.

[certik]

See also: https://gitlab.com/lfortran/lfortran/-/issues/666

As discussed there, I think we should move to (size, start_index) representation of arrays. I don't have an opinion whether we should get rid of start_index, which would mean adjusting/offsetting all array indexing (there are pros/cons of doing that). So first let's keep the start_index. We should not offset any indices (that's the whole point of storing start_index in the first place).

[czgdp1807]

Well, my main concern is offsetting indices. Either you always do it in an optimisation pass or you never do it because once an ASR is formed you never know whether the source was Python or Fortran. So offsetting indices should never be done in any frontend irrespective of which array representation we are using.

Anyways would it be okay if I remove offsetting indices by 1 in LPython? Let me know.

[certik]

Yes, we should not offset indices in array indexing. So yes, please remove any such code.

[czgdp1807]

Great. I slept on it. I think it won’t be good idea to do it in #675 as it will be out of context. I will do it in a subsequent PR.