/** * Checks that the tag we are matching over is a supertag of every tag in the case-list. * * <p>This ensures that each tag could actually have a match and that case is not unreachable * code. * * @param matchingOverTag */ private void checkStaticSubtags(TaggedInfo matchingOver) { for (Case c : cases) { TaggedInfo matchTarget = TaggedInfo.lookupTagByType(c.getTaggedTypeMatch()); // FIXME: if (!isSubtag(matchTarget, matchingOver)) { ToolError.reportError( ErrorMessage.UNMATCHABLE_CASE, this.matchingOver, matchingOver.getTagName(), matchTarget.getTagName()); } } }
private void checkSubtagsPreceedSupertags() { // A tag cannot be earlier than one of its subtags for (int i = 0; i < cases.size() - 1; i++) { Case beforeCase = cases.get(i); TaggedInfo beforeTag = TaggedInfo.lookupTagByType(beforeCase.getTaggedTypeMatch()); // FIXME: for (int j = i + 1; j < cases.size(); j++) { Case afterCase = cases.get(j); if (afterCase.isDefault()) break; TaggedInfo afterTag = TaggedInfo.lookupTagByType(afterCase.getTaggedTypeMatch()); // FIXME: // TagBinding afterBinding = TagBinding.get(afterCase.getTaggedTypeMatch()); if (afterTag != null && beforeTag != null && isSubtag(afterTag, beforeTag)) { ToolError.reportError( ErrorMessage.SUPERTAG_PRECEEDS_SUBTAG, matchingOver, beforeTag.getTagName(), afterTag.getTagName()); } } } }
private void checkAllCasesAreTagged(Environment env) { // All things we match over must be tagged types for (Case c : cases) { if (c.isDefault()) continue; Type tagName = c.getTaggedTypeMatch(); if (tagName instanceof UnresolvedType) { UnresolvedType ut = (UnresolvedType) tagName; // System.out.println("ut = " + ut.resolve(env)); } if (tagName instanceof TypeInv) { // TypeInv ti = (TypeInv) tagName; // System.out.println("ti = " + ti.resolve(env)); // tagName = ti.resolve(env); // if (tagName instanceof UnresolvedType) { // tagName = ((UnresolvedType) tagName).resolve(env); // } DO NOT UNCOMMENT THIS AS BREAKS CASES return; // FIXME: Assume TypeInv will sort itself out during runtime. } // System.out.println(tagName); // check type exists // TypeBinding type = env.lookupType(tagName.toString()); // FIXME: // if (type == null) { // ToolError.reportError(ErrorMessage.TYPE_NOT_DECLARED, this, tagName.toString()); // } // check it is tagged TaggedInfo info = TaggedInfo.lookupTagByType(tagName); // FIXME: if (info == null) { ToolError.reportError(ErrorMessage.TYPE_NOT_TAGGED, matchingOver, tagName.toString()); } } }
@Override public Value evaluate(EvaluationEnvironment env) { // TaggedInfo.resolveAll(env, this); Type mo = matchingOver.getType(); TaggedInfo matchingOverTag = TaggedInfo.lookupTagByType(mo); // FIXME: if (matchingOver instanceof Variable) { Variable w = (Variable) matchingOver; // ClassType wType = (ClassType) env.lookup(w.getName()).getType(); // System.out.println("wType = " + wType); // System.out.println("looked up = " + TaggedInfo.lookupTagByType(wType)); // System.out.println("but mot = " + matchingOverTag); matchingOverTag = ((Obj) env.lookup(w.getName()) .map(ib -> ib.getValue(env)) .orElseThrow(() -> new RuntimeException("Invalid matching over tag"))) .getTaggedInfo(); } // System.out.println("Evaluating match with matchingOver = " + matchingOver + " its class " + // matchingOver.getClass()); /* Variable v = (Variable) matchingOver; System.out.println("v.getType() = " + v.getType()); System.out.println("v.getName() = " + v.getName()); System.out.println(env); System.out.println(env.lookup(v.getName())); System.out.println("mo = " + mo + " and its class is " + mo.getClass()); System.out.println(env.lookup(v.getName()).getUse()); System.out.println(env.lookup(v.getName()).getValue(env)); TypeType ttmo = (TypeType) mo; System.out.println("ttmo.getName() is declared but not actual type = " + ttmo.getName()); TypeType tttmo = (TypeType) ((MetadataWrapper) v.typecheck(env, Optional.empty())).getInner(); System.out.println("v.type = " + tttmo.getName()); TaggedInfo.dumpall(env); */ // System.out.println("Evaluating match over tag: " + matchingOverTag + " with matchingOver = " // + matchingOver.getType()); if (matchingOver.getType() instanceof ClassType) { ClassType ct = (ClassType) matchingOver.getType(); // System.out.println("hmm = " + this.matchingOver.typecheck(env, Optional.empty())); // System.out.println("ct = " + ct.getName()); } // System.out.println("matchingOverTag (latest) = " + matchingOverTag); int cnt = 0; for (Case c : cases) { cnt++; // String caseTypeName = getTypeName(c.getAST()); // System.out.println("case "+ cnt + " = " + c); Type tt = c.getTaggedTypeMatch(); TaggedInfo caseTag; if (tt instanceof TypeInv) { TypeInv ti = (TypeInv) tt; // System.out.println("Processing TypeInv case: " + ti); // FIXME: In ECOOP2015Artifact, I am trying to tell the difference between winMod.Win and // bigWinMod.Win... Type ttti = ti.getInnerType(); String mbr = ti.getInvName(); if (ttti instanceof UnresolvedType) { Value objVal = env.lookup(((UnresolvedType) ttti).getName()).get().getValue(env); caseTag = ((Obj) objVal) .getIntEnv() .lookupBinding(mbr, HackForArtifactTaggedInfoBinding.class) .map(b -> b.getTaggedInfo()) .orElseThrow(() -> new RuntimeException("Invalid tag invocation")); } else { // tt = ti.resolve(env); TODO: is this valid? caseTag = TaggedInfo.lookupTagByType(tt); // FIXME: } } else { caseTag = TaggedInfo.lookupTagByType(tt); // FIXME: } // System.out.println("case " + cnt + " type = " + tt); // System.out.println("caseTag = " + caseTag); if (caseTag != null && isSubtag(matchingOverTag, caseTag)) { // We've got a match, evaluate this case // System.out.println("MAAAAATTTCH!"); return c.getAST().evaluate(env); } } // No match, evaluate the default case // System.out.println("DEFAULT: " + defaultCase.getAST().evaluate(env)); return defaultCase.getAST().evaluate(env); }
@Override protected Type doTypecheck(Environment env, Optional<Type> expected) { this.resolve(env); Type matchOverType = matchingOver.typecheck(env, expected); // System.out.println("env = " + env); // System.out.println("matchingOver = " + matchingOver); // System.out.println("matchOverType = " + matchOverType); if (!(matchingOver instanceof Variable)) { throw new RuntimeException("Can only match over variable"); } // Variable v = (Variable) matchingOver; // System.out.println("v = " + v); // System.out.println("v.getType()=" + v.getType()); StaticTypeBinding staticBinding = getStaticTypeBinding(matchingOver, env); // System.out.println(staticBinding); /* if (staticBinding == null) { throw new RuntimeException("variable matching over must be statically tagged"); } */ // Variable we're matching must exist and be a tagged type // String typeName = getTypeName(matchOverType); TaggedInfo matchTaggedInfo = TaggedInfo.lookupTagByType(matchOverType); // FIXME: // System.out.println(matchOverType); if (matchTaggedInfo == null) { ToolError.reportError(ErrorMessage.TYPE_NOT_TAGGED, matchingOver, matchOverType.toString()); } // System.out.println(matchTaggedInfo); matchTaggedInfo.resolve(env, this); // System.out.println(matchTaggedInfo); checkNotMultipleDefaults(); checkDefaultLast(); Type returnType = typecheckCases(env, expected); checkAllCasesAreTagged(env); checkAllCasesAreUnique(); checkSubtagsPreceedSupertags(); // ONLY FOR STATICS FIXME: // System.out.println(env); if (staticBinding != null) { NameBinding nb = env.lookup(staticBinding.getTypeName()); if (nb != null) { checkStaticSubtags(TaggedInfo.lookupTagByType(nb.getType())); // matchTaggedInfo checkBoundedAndUnbounded(TaggedInfo.lookupTagByType(nb.getType())); // matchTaggedInfo } } // If we've omitted default, we must included all possible sub-tags if (defaultCase == null) { // first, the variables tag must use comprised-of! // next, the match cases must include all those in the comprises-of list if (true) {} } // If we've included default, we can't have included all subtags for a tag using comprised-of if (defaultCase != null) { // We only care if tag specifies comprises-of if (matchTaggedInfo.hasComprises()) { // all subtags were specified, error if (comprisesSatisfied(matchTaggedInfo)) { // ToolError.reportError(ErrorMessage.DEFAULT_PRESENT, matchingOver); } } } // System.out.println(expected); if (returnType == null) { if (defaultCase != null) { if (!expected.equals(Optional.empty())) { // System.out.println(defaultCase.getAST().getType()); // System.out.println(expected.get()); if (!expected.get().equals(defaultCase.getAST().getType())) { ToolError.reportError(ErrorMessage.MATCH_NO_COMMON_RETURN, this); return null; } } } } return returnType; }