public static void Test3_preCH_delta()
{
// basic
var C1 = new TypedSingleCH <sC1>();
var C2 = new TypedSingleCH <sC2>();
var C3 = new TypedSingleCH <sC3>();
var clSC = new CH_closedScope()
.decl("c1", C1)
.decl("c2", C2)
.decl("c3", C3);
var D1 = new TypedSingleCH <sD1>();
var D2 = new TypedSingleCH <sD2>();
var D3 = new TypedSingleCH <sD3>();
var pD1 = new adapter_preCH(D1);
var pD2 = new adapter_preCH(D2);
var pD3 = new adapter_preCH(D3);
var pdeltaSC = new preCH_deltaScope(clSC)
.decl("c1", pD1)
.decl("delta_2", pD2);
AssertEquivalent(pdeltaSC.instantiate().close(),
new [] { "delta_2", "c1", "c3", "c2" },
new TypedCH[] { D2, D1, C3, C2 });
// todo : MOAR!
Console.WriteLine("================= preDeltaScoping ok ============= ");
}
public static void Equivalent(CH_closedScope cls, preCH_deltaScope deltaSC)
{
int common_count = cls.refs().Count();
var test = cls.refs().Zip(deltaSC.refs(), (ref_L, ref_R) => ReferenceEquals(ref_L.CH, ref_R.pre_ch.CH));
D.Assert(test.All(_ => _)); // all true
D.Assert(test.Count() == common_count); // re-evals ... stress testing is never bad
}
preCH_deltaScope(CH_closedScope origScope, LL <preCH> origLL, LL <preCH> own, LL <preCH> extnls)
{
D.Assert(origScope != null);
this.origScope = origScope;
origLL_head = origLL;
ownLL_head = own;
externals = extnls;
} // the readonlys need a detour over constructor
public preCH_deltaScope(CH_closedScope clSC)
{
D.Assert(clSC != null);
origScope = clSC;
foreach (var nodeCH in clSC.LL_head.LIFO_shadowed().Reverse())
{
origLL_head = origLL_head.chain(nodeCH.name, new adapter_preCH(nodeCH.pay));
}
}
public CH_deltaScope(CH_closedScope clsSc)
{
if (clsSc == null)
{
throw new ScopeException("origin scope can't be null");
}
orig_scope = clsSc;
// own and externals stay empty
}
public CH_deltaScope(CH_closedScope clsSc, LL <TypedCH> ll, LL <TypedCH> externals)
{
if (clsSc == null)
{
throw new ScopeException("origin scope can't be null");
}
orig_scope = clsSc;
this.ownLL_head = ll;
this.externals = externals;
}
// to be able to write down expected result in a readable way
public static void AssertEquivalent(CH_closedScope cls, string [] names, TypedCH [] CHs)
{
D.Assert(names.Length == CHs.Length);
// cls.refs().NLSendRec("scope refs" , 1 , (_obj) => doing( (CH_Scope.Ref) _obj ) ); // git f****d this prototype
var zipped_refs = names
.Zip(CHs, (n, ch) => new CH_Scope.Ref {
name = n, CH = ch
})
/*.NLSendRec("zpipped" , 1 , doing )*/;
var test = cls.refs().Zip(zipped_refs,
(r_left, r_right) =>
(r_left.name == r_right.name) && //.NLSend("name_equal")
ReferenceEquals(r_left.CH, r_right.CH) //.NLSend("ref_equal")
).NLSendRec();
D.Assert(names.Length == test.Count());
D.Assert(test.All(_ => _));
}
// not quite sure yet
// this is for TURX .... probably most sensible to swap the inheritance arrow between TU > TURX
// Concrete TUs already use something like this, but by convention only rather then interface - this might actually be the better solution
//public virtual preCH preCH_out => VBoxTUs.Last().preCH_out;
// translation phases
public preCH_deltaScope scope(CH_closedScope c)
{
return(scope(new preCH_deltaScope(c)));
}
public static void Test2_basic_scoping()
{
var closA = new TypedSingleCH <int>();
var closB = new TypedMultiCH <string>(); // types and kinds don't matter
var closedSC = new CH_closedScope()
.decl("cA", closA)
.decl("cB", closB);
var D1 = new TypedSingleCH <int>();
var D2 = new TypedMultiCH <string>(); // types and kinds don't matter
TypedCH dummy1;
TypedCH dummy2;
var deltaCH = new CH_deltaScope(closedSC)
.decl("new name", D1)
.addRef("cA", out dummy1)
.addRef("new name", out dummy2);
D.Assert(object.ReferenceEquals(dummy1, closA));
D.Assert(object.ReferenceEquals(dummy2, D1));
D.Assert(
deltaCH.external_refs().Select(_ref => _ref.name).
SequenceEqual(new [] { "cA" }) // ref for "new name" is not external
);
// ----------------------------
var deltaCH2 = new CH_deltaScope(closedSC)
.decl("cA", D1)
.decl("cA", D1)
.decl("cA", D1)
.decl("cB", D1) // shadow both, multiple "cA"s are compressed to one in LIFO_shadowed
.decl("cA", D2) // shadow cA again with a different target
.addRef("cA", out dummy1);
var expected_names = new [] { "cA", "cB" }; // in reverse of insertion order
var expected_chs = new TypedCH[] { D2, D1 }; // for cA , cB resp.
D.Assert(deltaCH2.refs().Select(r => r.name).SequenceEqual(expected_names));
D.Assert(deltaCH2.refs().Select(r => r.CH).SequenceEqual(expected_chs));
// -------------------------------------
var closFunky = new TypedSingleCH <object>();
var origSC = new CH_closedScope()
.decl("cA", closFunky) // never see this guy
.decl("cA", closA)
.decl("cB", closB);
var sh1 = new TypedMultiCH <float>();
TypedCH sh_dummy1 = null;
TypedCH sh_dummy2 = null;
var shadowDelta1 = new CH_deltaScope(origSC)
.decl("sh1", sh1)
.addRef("cA", out sh_dummy1) // external ref
.decl("cA", sh1)
.addRef("cA", out sh_dummy2) // now cA is both an external and internal ref
;
// cB is not touched , thus :
// refs in order : [ "cA" -> sh_dummy2 == sh1 | "sh1" -> sh1 | "cB" -> closB ]
// ["cA" -> closA == sh_dummy1] is preserved in external_refs
D.Assert(ReferenceEquals(sh_dummy1, closA));
D.Assert(ReferenceEquals(sh_dummy2, sh1));
expected_names = new [] { "cA", "sh1", "cB" };
expected_chs = new TypedCH[] { sh1, sh1, closB };
D.Assert(shadowDelta1.refs().Select(r => r.name).SequenceEqual(expected_names));
D.Assert(shadowDelta1.refs().Select(r => r.CH).SequenceEqual(expected_chs));
D.Assert(shadowDelta1.external_refs().Select(r => r.name).SequenceEqual(new [] { "cA" }));
D.Assert(shadowDelta1.external_refs().Select(r => r.CH).SequenceEqual(new TypedCH[] { closA }));
// heheh :) two chaining deltaScopes need no extra testing new DeltaScope ( fromDeltaScope ) is identical to its original in all fields - there is no point to this
Console.WriteLine("================= basicScoping ok ============= ");
}