Example 1 with PathSPath
use of ast.Util.PathSPath in project L42 by ElvisResearchGroup.
the class Redirect method redirectOkAux.
private static void redirectOkAux(Program p, PathSPath current, ClassB cbTop, List<PathSPath> ambiguities, List<SPathSPath> exceptions) {
assert current.getPathsSet().size() == 1;
List<Ast.C> cs = current.getPath().getCBar();
if (cs.isEmpty()) {
throw Errors42.errorInvalidOnTopLevel();
}
Errors42.checkExistsPathMethod(cbTop, cs, Optional.empty());
//Boolean[] csPrivate=new Boolean[]{false};
ClassB currentIntCb = cbTop.getClassB(cs);
//path exists by construction.
Path path = current.getPathsSet().iterator().next();
ClassB currentExtCb;
if (path.isCore()) {
assert path.outerNumber() > 0 : path;
currentExtCb = p.extractClassB(path);
} else {
assert path.isPrimitive();
currentExtCb = ClassB.membersClass(Collections.emptyList(), Position.noInfo, cbTop.getPhase()).withInterface(path.equals(Path.Any()));
}
assert cs.stream().allMatch(c -> !c.isUnique());
boolean isPrivateState = ExtractInfo.hasPrivateState(currentIntCb);
boolean isNoImplementation = ExtractInfo.isNoImplementation(currentIntCb);
boolean headerOk = currentIntCb.isInterface() == currentExtCb.isInterface();
ClassKind kindSrc = ExtractInfo.classKind(cbTop, cs, currentIntCb, null, isPrivateState, isNoImplementation);
if (!headerOk && !currentIntCb.isInterface()) {
if (kindSrc == ClassKind.FreeTemplate) {
headerOk = true;
}
}
ClassKind kindDest = ExtractInfo.classKind(null, null, currentExtCb, null, null, null);
if (isPrivateState || !isNoImplementation) {
//unexpectedMembers stay empty if there is implementation
assert kindSrc != ClassKind.FreeTemplate || kindSrc != ClassKind.Template || kindSrc != ClassKind.Interface : kindSrc;
throw Errors42.errorSourceUnfit(current.getPath().getCBar(), path, kindSrc, kindDest, Collections.emptyList(), headerOk, Collections.emptyList());
}
redirectOkImpl(kindSrc, kindDest, ambiguities, current, currentIntCb, currentExtCb);
List<Member> unexpectedMembers = new ArrayList<>();
for (Member mi : currentIntCb.getMs()) {
Optional<Member> miPrime = Functions.getIfInDom(currentExtCb.getMs(), mi);
if (miPrime.isPresent() && miPrime.get().getClass().equals(mi.getClass())) {
Member miGet = miPrime.get();
redirectOkMember(ambiguities, exceptions, mi, miGet, current);
} else {
unexpectedMembers.add(mi);
}
}
if (unexpectedMembers.isEmpty() && headerOk) {
return;
}
if (kindSrc == null) {
kindSrc = ExtractInfo.classKind(cbTop, cs, currentIntCb, null, isPrivateState, isNoImplementation);
}
if (kindDest == null) {
kindDest = ExtractInfo.classKind(null, null, currentExtCb, null, null, null);
}
throw Errors42.errorSourceUnfit(cs, path, kindSrc, kindDest, unexpectedMembers, headerOk, Collections.emptyList());
}
Also used :
PathPath(ast.Util.PathPath)
PathSPath(ast.Util.PathSPath)
SPathSPath(ast.Util.SPathSPath)
CloneWithPath(coreVisitors.CloneWithPath)
Path(ast.Ast.Path)
C(ast.Ast.C)
ClassKind(is.L42.connected.withSafeOperators.ExtractInfo.ClassKind)
ArrayList(java.util.ArrayList)
Member(ast.ExpCore.ClassB.Member)
ClassB(ast.ExpCore.ClassB)
Example 2 with PathSPath
use of ast.Util.PathSPath in project L42 by ElvisResearchGroup.
the class Redirect method redirectOkImpl.
private static void redirectOkImpl(ClassKind kindSrc, ClassKind kindDest, List<PathSPath> ambiguities, PathSPath current, ClassB currentIntCb, ClassB currentExtCb) {
// List<Path>unexpectedInterfaces=new ArrayList<>(unexpectedI);
// Collections.sort(unexpectedInterfaces,(pa,pb)->pa.toString().compareTo(pb.toString()));
List<Path> extPs = currentExtCb.getSuperPaths();
Path destP = current.getPathsSet().iterator().next();
extPs = Map.of(pi -> From.fromP(pi, destP), extPs);
List<Path> unexpectedInterfaces = new ArrayList<>();
for (Path pi : currentIntCb.getSuperPaths()) {
Path pif = From.fromP(pi, current.getPath());
if (extPs.isEmpty()) {
unexpectedInterfaces.add(pif);
} else if (pif.isPrimitive() || pif.outerNumber() > 0) {
if (!extPs.contains(pif)) {
unexpectedInterfaces.add(pif);
}
} else {
plusEqual(ambiguities, pif, extPs);
}
}
if (unexpectedInterfaces.isEmpty()) {
return;
}
throw Errors42.errorSourceUnfit(current.getPath().getCBar(), current.getPathsSet().iterator().next(), kindSrc, kindDest, Collections.emptyList(), true, unexpectedInterfaces);
}
Also used :
PathPath(ast.Util.PathPath)
PathSPath(ast.Util.PathSPath)
SPathSPath(ast.Util.SPathSPath)
CloneWithPath(coreVisitors.CloneWithPath)
Path(ast.Ast.Path)
From(coreVisitors.From)
Stage(ast.Ast.Stage)
PathPath(ast.Util.PathPath)
Arrays(java.util.Arrays)
Program(programReduction.Program)
Ast(ast.Ast)
Map(tools.Map)
Configuration(facade.Configuration)
ErrorMessage(ast.ErrorMessage)
Type(ast.Ast.Type)
CloneVisitorWithProgram(coreVisitors.CloneVisitorWithProgram)
Assertions(tools.Assertions)
MethodWithType(ast.ExpCore.ClassB.MethodWithType)
PathSPath(ast.Util.PathSPath)
Supplier(java.util.function.Supplier)
SPathSPath(ast.Util.SPathSPath)
ArrayList(java.util.ArrayList)
HashSet(java.util.HashSet)
IsUsed(is.L42.connected.withSafeOperators.ExtractInfo.IsUsed)
ClassB(ast.ExpCore.ClassB)
ClassKind(is.L42.connected.withSafeOperators.ExtractInfo.ClassKind)
NestedClass(ast.ExpCore.ClassB.NestedClass)
Iterator(java.util.Iterator)
CloneWithPath(coreVisitors.CloneWithPath)
Path(ast.Ast.Path)
Doc(ast.Ast.Doc)
Set(java.util.Set)
PopNFrom(is.L42.connected.withSafeOperators.Pop.PopNFrom)
ExpCore(ast.ExpCore)
Member(ast.ExpCore.ClassB.Member)
Functions(auxiliaryGrammar.Functions)
List(java.util.List)
Position(ast.Ast.Position)
Optional(java.util.Optional)
FromInClass(coreVisitors.FromInClass)
C(ast.Ast.C)
Collections(java.util.Collections)
ArrayList(java.util.ArrayList)
Example 3 with PathSPath
use of ast.Util.PathSPath in project L42 by ElvisResearchGroup.
the class Redirect method redirectOk.
public static List<PathPath> redirectOk(Program p, ClassB cbTop, Path internal, Path external) {
List<PathPath> verified = new ArrayList<>();
verifiedForErrorMsg = verified;
List<PathSPath> ambiguities = new ArrayList<>();
List<SPathSPath> exceptions = new ArrayList<>();
ambiguities.add(new PathSPath(internal, new HashSet<>(Arrays.asList(external))));
for (PathSPath current = choseUnabigus(ambiguities); current != null; current = choseUnabigus(ambiguities)) {
//closure final limitations
PathSPath _current = current;
assert ambiguitiesOk(ambiguities);
assert verified.stream().allMatch(pp -> !pp.getPath1().equals(_current.getPath())) : verified + " " + _current.getPath();
redirectOkAux(p, current, cbTop, ambiguities, exceptions);
assert current.getPathsSet().size() == 1;
assert verified.stream().allMatch(pp -> !pp.getPath1().equals(_current.getPath())) : verified + " " + _current.getPath();
verified.add(new PathPath(current.getPath(), current.getPathsSet().iterator().next()));
accumulateVerified(ambiguities, verified);
}
assert choseUnabigus(ambiguities) == null;
if (!ambiguities.isEmpty()) {
throw Errors42.errorIncoherentRedirectMapping(verified, ambiguities, null, Collections.emptyList());
}
checkExceptionOk(exceptions, verified);
return verified;
}
Also used :
PathSPath(ast.Util.PathSPath)
SPathSPath(ast.Util.SPathSPath)
PathPath(ast.Util.PathPath)
SPathSPath(ast.Util.SPathSPath)
ArrayList(java.util.ArrayList)
HashSet(java.util.HashSet)
Example 4 with PathSPath
use of ast.Util.PathSPath in project L42 by ElvisResearchGroup.
the class Redirect method plusEqual.
private static void plusEqual(List<PathSPath> ambiguities, Path pif, List<Path> extPs) {
assert ambiguitiesOk(ambiguities);
try {
assert !extPs.isEmpty();
assert !extPs.contains(null);
assert !pif.isPrimitive() && pif.outerNumber() == 0;
for (PathSPath psp : ambiguities) {
if (psp.getPath().equals(pif)) {
psp.setPathsSet(new HashSet<>(psp.getPathsSet()));
assert !psp.getPathsSet().isEmpty();
Path forErr = psp.getPathsSet().iterator().next();
psp.getPathsSet().retainAll(extPs);
if (psp.getPathsSet().isEmpty()) {
List<Path> psErr = Arrays.asList(forErr, extPs.get(0));
throw Errors42.errorIncoherentRedirectMapping(Redirect.verifiedForErrorMsg, ambiguities, psp.getPath(), psErr);
}
return;
}
}
ambiguities.add(new PathSPath(pif, new HashSet<>(extPs)));
} finally {
assert ambiguitiesOk(ambiguities);
}
}
Also used :
PathPath(ast.Util.PathPath)
PathSPath(ast.Util.PathSPath)
SPathSPath(ast.Util.SPathSPath)
CloneWithPath(coreVisitors.CloneWithPath)
Path(ast.Ast.Path)
PathSPath(ast.Util.PathSPath)
SPathSPath(ast.Util.SPathSPath)
HashSet(java.util.HashSet)
Example 5 with PathSPath
use of ast.Util.PathSPath in project L42 by ElvisResearchGroup.
the class Redirect method redirectOkMember.
private static void redirectOkMember(List<PathSPath> ambiguities, List<SPathSPath> exceptions, Member mi, Member miGet, PathSPath current) {
if (mi instanceof NestedClass) {
assert miGet instanceof NestedClass;
assert ((NestedClass) mi).getName().equals(((NestedClass) miGet).getName());
Path src = current.getPath().pushC(((NestedClass) mi).getName());
Path dest = current.getPathsSet().iterator().next().pushC(((NestedClass) mi).getName());
plusEqual(ambiguities, src, Arrays.asList(dest));
return;
}
assert mi.getClass().equals(miGet.getClass());
assert mi instanceof MethodWithType : mi;
MethodWithType mwtSrc = (MethodWithType) mi;
MethodWithType mwtDest = (MethodWithType) miGet;
//this is what happens in p.method
mwtSrc = From.from(mwtSrc, current.getPath());
mwtDest = From.from(mwtDest, current.getPathsSet().iterator().next());
assert mwtSrc.getMs().equals(mwtDest.getMs());
boolean thisMdfOk = mwtSrc.getMt().getMdf().equals(mwtDest.getMt().getMdf());
boolean retOk = redirectOkT(ambiguities, mwtSrc.getMt().getReturnType(), mwtDest.getMt().getReturnType());
List<Integer> parWrong = new ArrayList<Integer>();
{
int i = -1;
for (Type tSrc : mwtSrc.getMt().getTs()) {
i += 1;
Type tDest = mwtDest.getMt().getTs().get(i);
if (!redirectOkT(ambiguities, tSrc, tDest)) {
parWrong.add(i);
}
;
}
}
boolean excOk = plusEqualAndExc(ambiguities, exceptions, current.getPath(), mwtSrc, mwtDest);
if (thisMdfOk && retOk && excOk && parWrong.isEmpty()) {
return;
}
throw Errors42.errorMethodClash(current.getPath().getCBar(), mwtSrc, mwtDest, excOk, parWrong, retOk, thisMdfOk, false);
}
Also used :
PathPath(ast.Util.PathPath)
PathSPath(ast.Util.PathSPath)
SPathSPath(ast.Util.SPathSPath)
CloneWithPath(coreVisitors.CloneWithPath)
Path(ast.Ast.Path)
Type(ast.Ast.Type)
MethodWithType(ast.ExpCore.ClassB.MethodWithType)
ArrayList(java.util.ArrayList)
NestedClass(ast.ExpCore.ClassB.NestedClass)
MethodWithType(ast.ExpCore.ClassB.MethodWithType)
Aggregations
PathPath (ast.Util.PathPath)8
PathSPath (ast.Util.PathSPath)8
Path (ast.Ast.Path)7
SPathSPath (ast.Util.SPathSPath)7
CloneWithPath (coreVisitors.CloneWithPath)6
ArrayList (java.util.ArrayList)5
HashSet (java.util.HashSet)3
C (ast.Ast.C)2
Doc (ast.Ast.Doc)2
Type (ast.Ast.Type)2
ClassB (ast.ExpCore.ClassB)2
Member (ast.ExpCore.ClassB.Member)2
MethodWithType (ast.ExpCore.ClassB.MethodWithType)2
NestedClass (ast.ExpCore.ClassB.NestedClass)2
ClassKind (is.L42.connected.withSafeOperators.ExtractInfo.ClassKind)2
Ast (ast.Ast)1
Position (ast.Ast.Position)1
Stage (ast.Ast.Stage)1
ErrorMessage (ast.ErrorMessage)1
ExpCore (ast.ExpCore)1
