"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "src/dmd/expressionsem.d" between
dmd-2.094.1.tar.gz and dmd-2.094.2.tar.gz

About: DMD (Digital Mars D) is the D reference compiler. D is an object-oriented, imperative, multi-paradigm system programming language.

expressionsem.d  (dmd-2.094.1):expressionsem.d  (dmd-2.094.2)
skipping to change at line 64 skipping to change at line 64
import dmd.intrange; import dmd.intrange;
import dmd.mtype; import dmd.mtype;
import dmd.nspace; import dmd.nspace;
import dmd.opover; import dmd.opover;
import dmd.optimize; import dmd.optimize;
import dmd.parse; import dmd.parse;
import dmd.root.ctfloat; import dmd.root.ctfloat;
import dmd.root.file; import dmd.root.file;
import dmd.root.filename; import dmd.root.filename;
import dmd.root.outbuffer; import dmd.root.outbuffer;
import dmd.root.rmem;
import dmd.root.rootobject; import dmd.root.rootobject;
import dmd.root.string; import dmd.root.string;
import dmd.semantic2; import dmd.semantic2;
import dmd.semantic3; import dmd.semantic3;
import dmd.sideeffect; import dmd.sideeffect;
import dmd.safe; import dmd.safe;
import dmd.target; import dmd.target;
import dmd.tokens; import dmd.tokens;
import dmd.traits; import dmd.traits;
import dmd.typesem; import dmd.typesem;
skipping to change at line 466 skipping to change at line 465
{ {
if (td.overroot) if (td.overroot)
td = td.overroot; td = td.overroot;
s = td; s = td;
} }
} }
if (ue.op == TOK.dotTemplateInstance) if (ue.op == TOK.dotTemplateInstance)
{ {
DotTemplateInstanceExp dti = cast(DotTemplateInstanceExp)ue; DotTemplateInstanceExp dti = cast(DotTemplateInstanceExp)ue;
auto ti = Pool!TemplateInstance.make(loc, s.ident, dti.ti.tiargs); auto ti = new TemplateInstance(loc, s.ident, dti.ti.tiargs);
if (!ti.updateTempDecl(sc, s)) if (!ti.updateTempDecl(sc, s))
return ErrorExp.get(); return ErrorExp.get();
return new ScopeExp(loc, ti); return new ScopeExp(loc, ti);
} }
else else
{ {
//printf("-searchUFCS() %s\n", s.toChars()); //printf("-searchUFCS() %s\n", s.toChars());
return new DsymbolExp(loc, s); return new DsymbolExp(loc, s);
} }
} }
skipping to change at line 1440 skipping to change at line 1439
/* This applies ?: to merge the types. It's backwards; /* This applies ?: to merge the types. It's backwards;
* ?: should call this function to merge types. * ?: should call this function to merge types.
*/ */
condexp.type = null; condexp.type = null;
condexp.e1 = e0; condexp.e1 = e0;
condexp.e2 = e; condexp.e2 = e;
condexp.loc = e.loc; condexp.loc = e.loc;
Expression ex = condexp.expressionSemantic(sc); Expression ex = condexp.expressionSemantic(sc);
if (ex.op == TOK.error) if (ex.op == TOK.error)
e = ex; e = ex;
else if (e.op == TOK.function_ || e.op == TOK.delegate_)
{
// https://issues.dlang.org/show_bug.cgi?id=21285
// Functions and delegates don't convert correctly with castTo b
elow
(*exps)[j0] = condexp.e1;
e = condexp.e2;
}
else else
{ {
// Convert to common type // Convert to common type
(*exps)[j0] = condexp.e1.castTo(sc, condexp.type); (*exps)[j0] = condexp.e1.castTo(sc, condexp.type);
e = condexp.e2.castTo(sc, condexp.type); e = condexp.e2.castTo(sc, condexp.type);
} }
} }
j0 = i; j0 = i;
e0 = e; e0 = e;
t0 = e.type; t0 = e.type;
skipping to change at line 2581 skipping to change at line 2587
if (s) if (s)
{ {
if (s.errors) if (s.errors)
return setError(); return setError();
Expression e; Expression e;
/* See if the symbol was a member of an enclosing 'with' /* See if the symbol was a member of an enclosing 'with'
*/ */
WithScopeSymbol withsym = scopesym.isWithScopeSymbol(); WithScopeSymbol withsym = scopesym.isWithScopeSymbol();
if (withsym && withsym.withstate.wthis) if (withsym && withsym.withstate.wthis && symbolIsVisible(sc, s))
{ {
/* Disallow shadowing /* Disallow shadowing
*/ */
// First find the scope of the with // First find the scope of the with
Scope* scwith = sc; Scope* scwith = sc;
while (scwith.scopesym != scopesym) while (scwith.scopesym != scopesym)
{ {
scwith = scwith.enclosing; scwith = scwith.enclosing;
assert(scwith); assert(scwith);
} }
skipping to change at line 2616 skipping to change at line 2622
// TODO: DotIdExp.semantic will find 'ident' from 'wthis' again . // TODO: DotIdExp.semantic will find 'ident' from 'wthis' again .
// The redudancy should be removed. // The redudancy should be removed.
e = new VarExp(exp.loc, withsym.withstate.wthis); e = new VarExp(exp.loc, withsym.withstate.wthis);
e = new DotIdExp(exp.loc, e, exp.ident); e = new DotIdExp(exp.loc, e, exp.ident);
e = e.expressionSemantic(sc); e = e.expressionSemantic(sc);
} }
else else
{ {
if (withsym) if (withsym)
{ {
if (auto t = withsym.withstate.exp.isTypeExp()) if (withsym.withstate.exp.type.ty != Tvoid)
{ {
e = new TypeExp(exp.loc, t.type); // 'with (exp)' is a type expression
e = new DotIdExp(exp.loc, e, exp.ident); // or 's' is not visible there (for error message)
result = e.expressionSemantic(sc); e = new TypeExp(exp.loc, withsym.withstate.exp.type);
return; }
else
{
// 'with (exp)' is a Package/Module
e = withsym.withstate.exp;
} }
e = new DotIdExp(exp.loc, e, exp.ident);
result = e.expressionSemantic(sc);
return;
} }
/* If f is really a function template, /* If f is really a function template,
* then replace f with the function template declaration. * then replace f with the function template declaration.
*/ */
FuncDeclaration f = s.isFuncDeclaration(); FuncDeclaration f = s.isFuncDeclaration();
if (f) if (f)
{ {
TemplateDeclaration td = getFuncTemplateDecl(f); TemplateDeclaration td = getFuncTemplateDecl(f);
if (td) if (td)
skipping to change at line 4170 skipping to change at line 4183
if (p.type.ty == Tident && (cast(TypeIdentifier)p.type).iden t == tp.ident) if (p.type.ty == Tident && (cast(TypeIdentifier)p.type).iden t == tp.ident)
{ {
Expression e = (*arguments)[u]; Expression e = (*arguments)[u];
tiargs.push(e.type); tiargs.push(e.type);
break; break;
} }
} }
} }
auto ti = Pool!TemplateInstance.make(exp.loc, exp.td, tiargs); auto ti = new TemplateInstance(exp.loc, exp.td, tiargs);
return (new ScopeExp(exp.loc, ti)).expressionSemantic(sc); return (new ScopeExp(exp.loc, ti)).expressionSemantic(sc);
} }
return exp.expressionSemantic(sc); return exp.expressionSemantic(sc);
} }
override void visit(CallExp exp) override void visit(CallExp exp)
{ {
static if (LOGSEMANTIC) static if (LOGSEMANTIC)
{ {
printf("CallExp::semantic() %s\n", exp.toChars()); printf("CallExp::semantic() %s\n", exp.toChars());
 End of changes. 8 change blocks. 
9 lines changed or deleted 23 lines changed or added

Home  |  About  |  Features  |  All  |  Newest  |  Dox  |  Diffs  |  RSS Feeds  |  Screenshots  |  Comments  |  Imprint  |  Privacy  |  HTTP(S)