On Monday, 1 July 2013 at 01:56:22 UTC, Timon Gehr wrote:
On 07/01/2013 03:08 AM, Kenji Hara wrote:
2013/7/1 JS <js.m...@gmail.com <mailto: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
The described strategy can easily result in non-termination,
and which template instantiations it performs can be
non-obvious.
auto foo(T)(T arg){
static if(is(T==int)) return 1.0;
else return 1;
}
void main(){
auto x;
x = 1;
x = foo(x);
}
Sorry, it only results in non-termination if you don't check all
return types out of a function. It is a rather easy case to
handle by just following all the return types and choosing the
largest one. No big deal... any other tries?
