diff options
author | Martin Odersky <odersky@gmail.com> | 2004-06-03 12:33:10 +0000 |
---|---|---|
committer | Martin Odersky <odersky@gmail.com> | 2004-06-03 12:33:10 +0000 |
commit | 682856e0623ddc61442f644e4935ce449480a958 (patch) | |
tree | cff46c30cb93f91230cb24713013d3d80ecb1509 /sources/scalac/symtab/Type.java | |
parent | d94a30d34746ddbe4274c00231734e2bbc3e9ff5 (diff) | |
download | scala-682856e0623ddc61442f644e4935ce449480a958.tar.gz scala-682856e0623ddc61442f644e4935ce449480a958.tar.bz2 scala-682856e0623ddc61442f644e4935ce449480a958.zip |
*** empty log message ***
Diffstat (limited to 'sources/scalac/symtab/Type.java')
-rw-r--r-- | sources/scalac/symtab/Type.java | 101 |
1 files changed, 77 insertions, 24 deletions
diff --git a/sources/scalac/symtab/Type.java b/sources/scalac/symtab/Type.java index 8f57093823..e88240a56f 100644 --- a/sources/scalac/symtab/Type.java +++ b/sources/scalac/symtab/Type.java @@ -197,7 +197,7 @@ public class Type implements Modifiers, Kinds, TypeTags, EntryTags { } public static Type typeRef(Type pre, Symbol sym, Type[] args) { - if (!pre.isLegalPrefix() && !pre.isError()) + if (sym.kind == TYPE && !pre.isLegalPrefix() && !pre.isError()) throw new Type.Malformed(pre, sym.nameString()); rebind: if (sym.isAbstractType()) { @@ -225,7 +225,7 @@ public class Type implements Modifiers, Kinds, TypeTags, EntryTags { return new ExtTypeRef(pre, sym, args); } private static boolean isLegalTypeRef(Type pre, Symbol sym, Type[] args) { - if (!pre.isLegalPrefix() && !pre.isError()) return false; + if (sym.kind == TYPE && !pre.isLegalPrefix() && !pre.isError()) return false; if (!sym.isType() && !sym.isError()) return false; // !!! return args.length == 0 || args.length == sym.typeParams().length; return true; @@ -687,9 +687,12 @@ public class Type implements Modifiers, Kinds, TypeTags, EntryTags { return true; case TypeRef(_, Symbol sym, _): if (sym.isParameter() && sym.isSynthetic()) return true; + return false; + /* return sym.kind == CLASS && ((sym.flags & JAVA) != 0 || (sym.flags & (TRAIT | ABSTRACT)) == 0); + */ default: return false; } @@ -806,33 +809,34 @@ public class Type implements Modifiers, Kinds, TypeTags, EntryTags { return sym.info().lookupNonPrivate(name); case CompoundType(Type[] parts, Scope members): Symbol sym = members.lookup(name); - if (sym.kind != NONE && (sym.flags & PRIVATE) == 0) - return sym; - - // search base types in reverse; non-abstract members - // take precedence over abstract ones. - int i = parts.length; - sym = Symbol.NONE; - while (i > 0) { - i--; - Symbol sym1 = parts[i].lookupNonPrivate(name); - if (sym1.kind != NONE && - (sym1.flags & PRIVATE) == 0 && - (sym.kind == NONE - || - (sym.flags & DEFERRED) != 0 && - (sym1.flags & DEFERRED) == 0 - || - (sym.flags & DEFERRED) == (sym1.flags & DEFERRED) && - sym1.owner().isSubClass(sym.owner()))) - sym = sym1; - } - return sym; + if (sym.kind != NONE && (sym.flags & PRIVATE) == 0) return sym; + else return lookupNonPrivate(parts, name); default: return Symbol.NONE; } } + public static Symbol lookupNonPrivate(Type[] parts, Name name) { + // search base types in reverse; non-abstract members + // take precedence over abstract ones. + int i = parts.length; + Symbol sym = Symbol.NONE; + while (i > 0) { + i--; + Symbol sym1 = parts[i].lookupNonPrivate(name); + if (sym1.kind != NONE && + (sym.kind == NONE + || + (sym.flags & DEFERRED) != 0 && + (sym1.flags & DEFERRED) == 0 + || + (sym.flags & DEFERRED) == (sym1.flags & DEFERRED) && + sym1.owner().isSubClass(sym.owner()))) + sym = sym1; + } + return sym; + } + /** * Looks up in the current type a symbol with the same name as the * given symbol and whose type (as seen from the given prefix) is @@ -2342,6 +2346,55 @@ public class Type implements Modifiers, Kinds, TypeTags, EntryTags { } } + /** Does this type match type `tp', so that corresponding symbols with + * the two types would be taken to override each other? + */ + public boolean overrides(Type tp) { + switch (this) { + case OverloadedType(Symbol[] alts, Type[] alttypes): + for (int i = 0; i < alttypes.length; i++) { + if (alttypes[i].overrides(tp)) return true; + } + return false; + default: + switch (tp) { + case MethodType(Symbol[] ps1, Type res1): + switch (this) { + case MethodType(Symbol[] ps, Type res): + if (ps.length != ps1.length) return false; + for (int i = 0; i < ps.length; i++) { + Symbol p1 = ps1[i]; + Symbol p = ps[i]; + if (!p1.type().isSameAs(p.type()) || + (p1.flags & (DEF | REPEATED)) != (p.flags & (DEF | REPEATED))) + return false; + } + return res.overrides(res1); + } + return false; + + case PolyType(Symbol[] ps1, Type res1): + switch (this) { + case PolyType(Symbol[] ps, Type res): + if (ps.length != ps1.length) return false; + for (int i = 0; i < ps.length; i++) + if (!ps1[i].info().subst(ps1, ps).isSameAs(ps[i].info()) || + !ps[i].loBound().isSameAs(ps1[i].loBound().subst(ps1, ps)) || + !ps[i].vuBound().isSameAs(ps1[i].vuBound().subst(ps1, ps))) + return false; + return res.overrides(res1.subst(ps1, ps)); + } + return false; + + case OverloadedType(_, _): + throw new ApplicationError("overrides inapplicable for " + tp); + + default: + return true; + } + } + } + // Closures and Least Upper Bounds --------------------------------------------------- /** The closure of this type, i.e. the widened type itself followed by all |