On 6/30/13 10:30 PM, JS wrote:
On Monday, 1 July 2013 at 01:08:49 UTC, Kenji Hara wrote:
2013/7/1 JS <js.m...@gmail.com>
I am simply talking about having the compiler enlarge the type if
needed.
(this is mainly for built in types since the type hierarchy is
explicitly
known)
Just a simple matter, it would *drastically* increase compilation time.
void foo()
{
auto elem;
auto arr = [elem];
elem = 1;
....
elem = 2.0;
// typeof(elem) change should modify the result of typeof(arr)
}
Such type dependencies between multiple variables are common in the
realistic program.
When `elem = 2.0;` is found, compiler should run semantic analysis of the
whole function body of foo _once again_, because the setting type of elem
ignites the change of typeof(arr), and it would affect the code meaning.
If another variable type would be modified, it also ignites the whole
function body semantic again.
After all, semantic analysis repetition would drastically increase.
I can easily imagine that the compilation cost would not be worth the
small
benefits.
Kenji Hara
No, this would be a brute force approach. Only one "preprocessing pass"
of (#lines) would be required. Since parsing statement by statement
already takes place, it should be an insignificant cost.
Believe me, it's not. Look at this:
---
int foo(int elem) {
return 1;
}
char foo(float elem) {
return 'a';
}
auto elem;
elem = 1;
auto other = foo(elem);
elem = other + 2.5;
---
Explain to me how the compiler would work in this case, step by step.
