net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/core/dom/Expression.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2005 IBM Corporation and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-v10.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  *******************************************************************************/
  11
  12 package net.sourceforge.phpdt.core.dom;
  13
  14 /**
  15  * Abstract base class of AST nodes that represent expressions.
  16  * There are several kinds of expressions.
  17  * <p>
  18  * <pre>
  19  * Expression:
  20  *    Name
  21  *    IntegerLiteral (includes decimal, hex, and octal forms; and long)
  22  *    FloatingPointLiteral (includes both float and double)
  23  *    CharacterLiteral
  24  *    NullLiteral
  25  *    BooleanLiteral
  26  *    StringLiteral
  27  *    TypeLiteral
  28  *    ThisExpression
  29  *    SuperFieldAccess
  30  *    FieldAccess
  31  *    Assignment
  32  *    ParenthesizedExpression
  33  *    ClassInstanceCreation
  34  *    ArrayCreation
  35  *    ArrayInitializer
  36  *    MethodInvocation
  37  *    SuperMethodInvocation
  38  *    ArrayAccess
  39  *    InfixExpression
  40  *    InstanceofExpression
  41  *    ConditionalExpression
  42  *    PostfixExpression
  43  *    PrefixExpression
  44  *    CastExpression
  45  *    VariableDeclarationExpression
  46  * </pre>
  47  * </p>
  48  *
  49  * @since 2.0
  50  */
  51 public abstract class Expression extends ASTNode {
  52
  53         /**
  54          * Creates a new AST node for an expression owned by the given AST.
  55          * <p>
  56          * N.B. This constructor is package-private.
  57          * </p>
  58          *
  59          * @param ast the AST that is to own this node
  60          */
  61         Expression(AST ast) {
  62                 super(ast);
  63         }
  64
  65         /**
  66          * Resolves and returns the compile-time constant expression value as
  67          * specified in JLS2 15.28, if this expression has one. Constant expression
  68          * values are unavailable unless bindings are requested when the AST is
  69          * being built. If the type of the value is a primitive type, the result
  70          * is the boxed equivalent (i.e., int returned as an <code>Integer</code>);
  71          * if the type of the value is <code>String</code>, the result is the string
  72          * itself. If the expression does not have a compile-time constant expression
  73          * value, the result is <code>null</code>.
  74          * <p>
  75          * Resolving constant expressions takes into account the value of simple
  76          * and qualified names that refer to constant variables (JLS2 4.12.4).
  77          * </p>
  78          * <p>
  79          * Note 1: enum constants are not considered constant expressions.
  80          * The result is always <code>null</code> for these.
  81          * </p>
  82          * <p>
  83          * Note 2: Compile-time constant expressions cannot denote <code>null</code>.
  84          * So technically {@link NullLiteral} nodes are not constant expressions.
  85          * The result is <code>null</code> for these nonetheless.
  86          * </p>
  87          *
  88          * @return the constant expression value, or <code>null</code> if this
  89          * expression has no constant expression value or if bindings were not
  90          * requested when the AST was created
  91          * @since 3.1
  92          */
  93         public final Object resolveConstantExpressionValue() {
  94                 return this.ast.getBindingResolver().resolveConstantExpressionValue(this);
  95         }
  96
  97         /**
  98          * Resolves and returns the binding for the type of this expression.
  99          * <p>
 100          * Note that bindings are generally unavailable unless requested when the
 101          * AST is being built.
 102          * </p>
 103          *
 104          * @return the binding for the type of this expression, or
 105          *    <code>null</code> if the type cannot be resolved
 106          */
 107         public final ITypeBinding resolveTypeBinding() {
 108                 return this.ast.getBindingResolver().resolveExpressionType(this);
 109         }
 110
 111         /**
 112          * Returns whether this expression node is the site of a boxing
 113          * conversion (JLS3 5.1.7). This information is available only
 114          * when bindings are requested when the AST is being built.
 115          *
 116          * @return <code>true</code> if this expression is the site of a
 117          * boxing conversion, or <code>false</code> if either no boxing conversion
 118          * is involved or if bindings were not requested when the AST was created
 119          * @since 3.1
 120          */
 121         public final boolean resolveBoxing() {
 122                 return this.ast.getBindingResolver().resolveBoxing(this);
 123         }
 124
 125         /**
 126          * Returns whether this expression node is the site of an unboxing
 127          * conversion (JLS3 5.1.8). This information is available only
 128          * when bindings are requested when the AST is being built.
 129          *
 130          * @return <code>true</code> if this expression is the site of an
 131          * unboxing conversion, or <code>false</code> if either no unboxing
 132          * conversion is involved or if bindings were not requested when the
 133          * AST was created
 134          * @since 3.1
 135          */
 136         public final boolean resolveUnboxing() {
 137                 return this.ast.getBindingResolver().resolveUnboxing(this);
 138         }
 139 }
 140