public Env(ValidationList validations, Class owner, Env parent)
{
Contract.Requires(validations != null);
Contract.Requires(parent != null);
this.validations = validations;
Owner = owner;
this.parent = parent;
}
private void specStm(Stm e, Env <Spec> env)
{
C.Nn(e, env);
switch (e)
{
case Declr d:
if (d.Exp == null)
{
env.Declare(d, NotSetSpec.Instance);
}
else
{
env.Declare(d, specExp(d.Exp, env, AnySpec.Instance));
if (d.Exp is Ident fromIdent)
{
d.AssignedFrom.Add(fromIdent);
}
d.Ident.Spec = d.Exp.Spec;
}
break;
case Assign a:
switch (a.To)
{
case Ident ident:
{
var orig = env.Get(ident, true).Value;
var slot3 = orig == NotSetSpec.Instance ? AnySpec.Instance : orig;
var s = specExp(a.Exp, env, slot3);
if (orig == NotSetSpec.Instance)
{
env.Set(ident, s);
}
if (a.Exp is Ident fromIdent)
{
a.AssignedFrom.Add(fromIdent);
}
break;
}
case MemberAccess ma:
{
var minObjEnv = env.Create();
var declr = new Let(
new Ident(ma.Ident.Name, ma.Ident.TokenType)
.CopyInfoFrom(ma.Ident, true), Void.Instance);
minObjEnv.Declare(declr, AnySpec.Instance);
var minObj = new ObjSpec(minObjEnv);
var maExpS = specExp(ma.Exp, env, minObj);
if (maExpS is ObjSpec objS)
{
var orig = objS.Env.Get(ma.Ident, true).Value;
var slot3 = orig == NotSetSpec.Instance ? AnySpec.Instance : orig;
var s = specExp(a.Exp, env, slot3);
if (orig == AnySpec.Instance)
{
objS.Env.Set(ma.Ident, s);
a.AssignedFrom.Add(ma.Ident);
}
}
break;
}
default:
throw new NotSupportedException();
}
break;
case Return r:
var slot2 = returns.Peek();
var retS = specExp(r.Exp, env, slot2 == NotSetSpec.Instance ? AnySpec.Instance : slot2);
returns.UpdateTop(retS);
break;
case Loop l:
specSequence(l.Body, env);
break;
case Break _:
break;
case Continue _:
break;
case Toss ts:
var _ = specExp(ts.Exception, env, AnySpec.Instance);
// TODO requires exp to be of some type?
break;
case Attempt att:
specSequence(att.Body, env);
if (att.Grab != null)
{
var grabEnv = env.Create();
var exDeclr = new Let(new Ident("exception", TokenType.Ident));
grabEnv.Declare(exDeclr, AnySpec.Instance);
specSequence(att.Grab, grabEnv);
}
if (att.AtLast != null)
{
specSequence(att.AtLast, env);
}
break;
case Import imp:
isImportContext = true;
var objSpecWithNoMembers = new ObjSpec(env.Create());
var modImpEl = specExp(imp.QualifiedIdent, env, objSpecWithNoMembers);
isImportContext = false;
if (modImpEl is ObjSpec modImp)
{
env.AddImport(imp.QualifiedIdent, modImp.Env, (Declr)modImp.Parent);
}
break;
case Sequence seq:
specSequence(seq, env);
break;
default:
throw new NotSupportedException();
}
}
private Spec specExp2(Exp exp, Env <Spec> env, Spec slot)
{
C.Nn(exp, env, slot);
C.ReturnsNn();
Spec ss;
switch (exp)
{
case Ident i:
if (isImportContext)
{
return(env.GetWithoutImports(i).Value);
}
else
{
var orig = env.Get(i).Value;
if (orig == NotSetSpec.Instance || orig == AnySpec.Instance)
{
//prog.RemarkList.AttemptToReadUninitializedVariableWarn(i);
setIdentAndAssignedFrom(env, i, slot);
return(slot);
}
if (!isAssignable(orig, slot))
{
prog.RemarkList.CannotConvertType(orig, slot, i);
}
return(orig);
}
case FnApply fna:
{
if (fna.Fn is Ident fnI && fnI.Name == "typeof")
{
if (!(fna.Arguments[0] is Spec))
{
fna.Arguments = new FnArguments(new List <Exp> {
specExp(fna.Arguments[0], env, AnySpec.Instance)
});
}
return(VoidSpec.Instance);
}
var orig = specExp(fna.Fn, env, AnySpec.Instance);
if (orig is FnSpec fnS)
{
if (fnS.ParameterSpec.Count != fna.Arguments.Count)
{
throw prog.RemarkList.ParameterArgumentCountMismatch(fna, fnS.ParameterSpec.Count);
}
var argumentSpecs = new List <Spec>();
var ix = 0;
foreach (var aa in fna.Arguments)
{
var pS = fnS.ParameterSpec[ix];
var aS = specExp(aa, env, pS);
argumentSpecs.Add(isAssignable(aS, pS) ? aS : pS);
++ix;
}
if (fna.Arguments.Count != 0 && fnS.Fn?.SpecEnv != null)
{
var newFn = new Fn(fnS.Fn.Parameters, fnS.Fn.Sequence, fnS.Fn.SpecEnv).CopyInfoFrom(fnS.Fn);
var newFnS = specFn(newFn, null, argumentSpecs);
fnS = newFnS;
}
if (!isAssignable(fnS.ReturnSpec, slot))
{
prog.RemarkList.CannotConvertType(fnS.ReturnSpec, slot, fna);
}
return(fnS.ReturnSpec);
}
var sigS = new List <Spec>();
foreach (var aa in fna.Arguments)
{
var aS = specExp(aa, env, AnySpec.Instance);
sigS.Add(aS);
}
sigS.Add(slot == NotSetSpec.Instance ? AnySpec.Instance : slot);
var newFnSpec = new FnSpec(sigS, null);
if (fna.Fn is Ident fnI2)
{
env.Set(fnI2, newFnSpec);
}
return(slot);
}
case Fn f:
return(specFn(f, env));
case When w:
var _ = specExp(w.Test, env, BoolSpec.Instance);
var thenS = specSequenceItem(w.Then, env, slot);
if (w.Otherwise == null)
{
return(VoidSpec.Instance);
}
else
{
var otherwiseS = specSequenceItem(w.Otherwise, env, slot);
if (!areSame(thenS, otherwiseS))
{
prog.RemarkList.CannotConvertType(thenS, otherwiseS, w.Otherwise);
}
return(thenS);
}
case ArrConstructor ae:
var s = new ArrSpec(commonType(ae.Arguments, env));
var notSetArgs = ae.Arguments.OfType <Ident>().ToList();
foreach (var a in notSetArgs)
{
var orig2 = env.Get(a).Value;
if (isAssignable(s.ItemSpec, orig2))
{
setIdentAndAssignedFrom(env, a, s.ItemSpec);
}
}
return(s);
case MemberAccess ma:
ss = specExp(ma.Exp, env, NotSetSpec.Instance);
var mai = ma.Ident;
if (ss is NotSetSpec || ss is AnySpec)
{
var objSEnv = env.Create();
var objS = new ObjSpec(objSEnv)
{
FromUsage = true
};
var declr = new Var(new Ident(mai.Name, mai.TokenType).CopyInfoFrom(mai, true));
objSEnv.Declare(declr, slot);
var __ = specExp(mai, objSEnv, slot);
ss = objS;
if (ma.Exp is Ident i)
{
setIdentAndAssignedFrom(env, i, objS);
}
}
var objS2 = ss as ObjSpec;
if (objS2 == null)
{
throw prog.RemarkList.OnlyObjectsCanHaveMembers(ma, ss);
}
if (objS2.FromUsage)
{
var member = objS2.Env.GetFromThisEnvOnlyOrNull(mai, null); // also use type and var/let?
if (member == null)
{
var declr = new Var(new Ident(mai.Name, mai.TokenType).CopyInfoFrom(mai, true));
objS2.Env.Declare(declr, slot);
var __ = specExp(mai, objS2.Env, slot);
}
}
var objSpec = (ObjSpec)ss;
ss = objSpec.Env.GetFromThisEnvOnly(mai, null).Value;
return(ss);
case New n:
var objEnv = env.Create();
foreach (var classItem in n.Body)
{
specStm(classItem, objEnv);
}
return(new ObjSpec(objEnv)
{
Parent = n.Parent
});
case Text _:
return(TextSpec.Instance);
case Bool _:
return(BoolSpec.Instance);
case Builtin bu:
return(bu.FixedSpec);
case Char _:
return(CharSpec.Instance);
case Int _:
return(IntSpec.Instance);
case Void _:
return(VoidSpec.Instance);
default:
throw new NotSupportedException();
}
}
public void AddImport(Env ie) => imports.Insert(0, new Env(validations, ie.dict));
static Env getEnvDeclaringOrNull(String name, Env env)
{
if (env.dict.ContainsKey(name))
return env;
if (env.imports.Count != 0)
{
foreach (var ie in env.imports)
{
if (ie.dict.ContainsKey(name))
return ie;
}
return null;
}
return env.parent == null ? null : getEnvDeclaringOrNull(name, env.parent);
}
Env getEnvDeclaring(String name, Env env)
{
var e = getEnvDeclaringOrNull(name, env);
if (e == null)
validations.GenericWarning("Env: variable '" + name + "' is not declared",
Void.Instance);
return e;
}
public static void PrintEnv(Env env)
{
Console.WriteLine("Env:");
var e = env;
var indent = "";
do
{
foreach (var d in e.dict)
{
Console.WriteLine(indent + d.Value.Accessibility + " var " + d.Key + " = " +
d.Value.Item.Accept(Program.DefaultPrinter));
}
indent += " ";
e = e.parent;
} while (e != null);
}
public IAsi CheckAccessibility(String name, Env e, String accessType)
{
if (e == null)
return null;
if (e == this)
return e.dict[name].Item;
var i = e.dict[name];
if (i.Accessibility == Accessibility.Private)
validations.GenericWarning(
"Cannot " + accessType + " private variable '" + name + "' from here.",
Void.Instance);
return i.Item;
}