summaryrefslogtreecommitdiff
path: root/sources/scalac/ast/TreeInfo.java
diff options
context:
space:
mode:
Diffstat (limited to 'sources/scalac/ast/TreeInfo.java')
-rw-r--r--sources/scalac/ast/TreeInfo.java307
1 files changed, 0 insertions, 307 deletions
diff --git a/sources/scalac/ast/TreeInfo.java b/sources/scalac/ast/TreeInfo.java
deleted file mode 100644
index caeb7d72c0..0000000000
--- a/sources/scalac/ast/TreeInfo.java
+++ /dev/null
@@ -1,307 +0,0 @@
-/* ____ ____ ____ ____ ______ *\
-** / __// __ \/ __// __ \/ ____/ SOcos COmpiles Scala **
-** __\_ \/ /_/ / /__/ /_/ /\_ \ (c) 2002, LAMP/EPFL **
-** /_____/\____/\___/\____/____/ **
-** **
-** $Id$
-\* */
-
-package scalac.ast;
-
-import scalac.ApplicationError;
-import scalac.util.Name;
-import scalac.util.Names;
-import scalac.symtab.Type;
-import scalac.symtab.Symbol;
-import scalac.symtab.Modifiers;
-
-import java.util.LinkedList;
-
-public class TreeInfo {
-
- public static boolean isTerm(Tree tree) {
- return tree.isTerm();
- }
-
- public static boolean isType(Tree tree) {
- return tree.isType();
- }
-
- public static boolean isOwnerDefinition(Tree tree) {
- switch (tree) {
- case PackageDef(_, _):
- case ClassDef(_, _, _, _, _, _):
- case ModuleDef(_, _, _, _):
- case DefDef(_, _, _, _, _, _):
- case Import(_, _):
- return true;
- default:
- return false;
- }
- }
-
- public static boolean isDefinition(Tree tree) {
- switch (tree) {
- case PackageDef(_, _):
- case ClassDef(_, _, _, _, _, _):
- case ModuleDef(_, _, _, _):
- case DefDef(_, _, _, _, _, _):
- case ValDef(_, _, _, _):
- case AbsTypeDef(_, _, _, _):
- case AliasTypeDef(_, _, _, _):
- case Import(_, _):
- return true;
- default:
- return false;
- }
- }
-
- public static boolean isDeclaration(Tree tree) {
- switch (tree) {
- case DefDef(_, _, _, _, _, Tree rhs):
- return rhs == Tree.Empty;
- case ValDef(_, _, _, Tree rhs):
- return rhs == Tree.Empty;
- case AbsTypeDef(_, _, _, _):
- case AliasTypeDef(_, _, _, _):
- return true;
- default:
- return false;
- }
- }
-
- /** Is tree a pure definition?
- */
- public static boolean isPureDef(Tree tree) {
- switch (tree) {
- case Tree.Empty:
- case ClassDef(_, _, _, _, _, _):
- case ModuleDef(_, _, _, _):
- case AbsTypeDef(_, _, _, _):
- case AliasTypeDef(_, _, _, _):
- case Import(_, _):
- return true;
- case DefDef(_, Name name, _, _, _, _):
- return name != Names.CONSTRUCTOR;
- case ValDef(int mods, _, _, Tree rhs):
- return (mods & Modifiers.MUTABLE) == 0 && isPureExpr(rhs);
- case DocDef(_, Tree definition):
- return isPureDef(definition);
- default:
- return false;
- }
- }
-
- /** Is tree a stable & pure expression?
- */
- public static boolean isPureExpr(Tree tree) {
- switch (tree) {
- case Empty:
- case This(_):
- case Super(_, _):
- return true;
- case Ident(_):
- assert tree.type != null : tree.toString();
- return tree.symbol().isStable();
- case Select(Tree qual, _):
- return tree.symbol().isStable() && isPureExpr(qual);
- case Apply(Tree fn, Tree[] args):
- return isPureExpr(fn) && args.length == 0;
- case TypeApply(Tree fn, Tree[] targs):
- return isPureExpr(fn);
- case Typed(Tree expr, _):
- return isPureExpr(expr);
- case Literal(_):
- return true;
- default:
- return false;
- }
- }
-
- /** Is tree a pure constructor?
- */
- public static boolean isPureConstr(Tree tree) {
- switch (tree) {
- case Ident(_):
- case Select(_, _):
- return tree.symbol() != null && tree.symbol().isPrimaryConstructor();
- case TypeApply(Tree constr, _):
- return isPureConstr(constr);
- case Apply(Tree fn, Tree[] args):
- return args.length == 0 && isPureConstr(fn);
- default:
- return false;
- }
- }
-
- /** Is tree a self constructor call?
- */
- public static boolean isSelfConstrCall(Tree tree) {
- switch (tree) {
- case Ident(Name name):
- return name == Names.CONSTRUCTOR;
- case TypeApply(Tree constr, _):
- return isSelfConstrCall(constr);
- case Apply(Tree constr, _):
- return isSelfConstrCall(constr);
- default:
- return false;
- }
- }
-
- /** Is tree a variable pattern
- */
- public static boolean isVarPattern(Tree pat) {
- switch (pat) {
- case Ident(Name name):
- return name.isVariable();
- default:
- return false;
- }
- }
-
- /** Is tree a this node which belongs to `enclClass'?
- */
- public static boolean isSelf(Tree tree, Symbol enclClass) {
- switch (tree) {
- case This(_):
- return tree.symbol() == enclClass;
- default:
- return false;
- }
- }
-
- /** The method symbol of an application node, or Symbol.NONE, if none exists.
- */
- public static Symbol methSymbol(Tree tree) {
- Tree meth = methPart(tree);
- if (meth.hasSymbol()) return meth.symbol();
- else return Symbol.NONE;
- }
-
- /** The method part of an application node
- */
- public static Tree methPart(Tree tree) {
- switch (tree) {
- case Apply(Tree fn, _):
- return methPart(fn);
- case TypeApply(Tree fn, _):
- return methPart(fn);
- case AppliedType(Tree fn, _):
- return methPart(fn);
- default:
- return tree;
- }
- }
-
- /** The symbol with name `name' imported from import clause `tree'.
- */
- public static Symbol importedSymbol(Tree tree, Name name) {
- switch (tree) {
- case Import(Tree expr, Name[] selectors):
- Type pre = tree.symbol().type();
- if (pre != Type.ErrorType) {
- boolean renamed = false;
- for (int i = 0; i < selectors.length; i = i + 2) {
- if (i + 1 < selectors.length && name.toTermName() == selectors[i + 1]) {
- if (name.isTypeName())
- return pre.lookupNonPrivate(selectors[i].toTypeName());
- else
- return pre.lookupNonPrivate(selectors[i]);
- } else if (name.toTermName() == selectors[i]) {
- renamed = true;
- } else if (selectors[i] == Names.IMPORT_WILDCARD && !renamed) {
- return pre.lookupNonPrivate(name);
- }
- }
- }
- return Symbol.NONE;
- default:
- throw new ApplicationError();
- }
- }
-
-
- /** returns true if the tree is a sequence-valued pattern.
- * precondition: tree is a pattern.
- * calls isSequenceValued( Tree, List ) because needs to remember bound
- * values.
- */
- public static boolean isSequenceValued( Tree tree ) {
- return isSequenceValued( tree, new LinkedList() );
- }
-
- /** returns true if the tree is a sequence-valued pattern.
- * precondition: tree is a pattern
- */
- public static boolean isSequenceValued( Tree tree, LinkedList recVars ) {
- switch( tree ) {
- case Bind(_, Tree t):
- recVars.addFirst( tree.symbol() );
- boolean res = isSequenceValued( t );
- recVars.removeFirst();
- return res;
- case Sequence(_):
- return true;
- case Alternative(Tree[] ts):
- for( int i = 0; i < ts.length; i++ ) {
- if( isSequenceValued( ts[ i ] ) )
- return true;
- }
- return false;
- case Ident(Name n): // if Ident is a recursive var, then true
- return recVars.contains( tree.symbol() );
- case Apply( _, _ ):
- case Literal( _ ):
- case Select(_,_):
- case Typed(_,_):
- return false;
- default:
- throw new scalac.ApplicationError("Unexpected pattern "+tree.getClass());
- }
- }
-
- /** returns true if the argument is an empty sequence pattern
- */
- public static boolean isEmptySequence( Tree tree ) {
- switch( tree ) {
- case Sequence( Tree ts[] ):
- return ( ts.length == 0 );
- default:
- return false;
- }
- }
- /** this test should correspond to the one used in TransMatch phase */
- public static boolean isRegularPattern( Tree tree ) {
- switch (tree) {
- case Alternative(_):
- return true;
- case Bind(_, Tree pat):
- return isRegularPattern( pat );
- case Ident(_):
- return false;
- case CaseDef(Tree pat, _, _):
- isRegularPattern(pat);
- break;
- case Sequence( Tree[] trees):
- return true;
- case Apply( _, Tree[] trees ):
- for( int i = 0; i < trees.length; i++ )
- if( isRegularPattern( trees[i] ) )
- return true;
- case Literal( _ ):
- return false;
-
- }
- return false;
- }
-
- /** @todo replace with cleaner test (e.g. of a symbol flag)
- */
- public static boolean isNameOfStarPattern( Name n ) {
- String s = n.toString();
- return (s.indexOf("$") != -1)
- &&(!s.startsWith("nest"));
- }
-
-}
generated by cgit v1.2.3 (git 2.39.1) at 2024-08-02 20:26:54 +0000