1) Moved net.sourceforge.phpeclipse.ui\src\net\sourceforge\phpdt back to net.sourcefo...
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / ast / MethodDeclaration.java
index 48fdda2..d41b0e8 100644 (file)
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package net.sourceforge.phpdt.internal.compiler.ast;
 
-import net.sourceforge.phpdt.internal.compiler.parser.OutlineableWithChildren;
-import net.sourceforge.phpdt.internal.compiler.parser.Outlineable;
-import net.sourceforge.phpdt.internal.compiler.ast.declarations.VariableUsage;
-import net.sourceforge.phpdt.internal.ui.PHPUiImages;
-import net.sourceforge.phpeclipse.PHPeclipsePlugin;
-import org.eclipse.jface.resource.ImageDescriptor;
-import org.eclipse.jface.text.Position;
-import org.eclipse.core.runtime.CoreException;
-
-import java.util.Hashtable;
-import java.util.Enumeration;
-import java.util.ArrayList;
-import java.util.List;
-
-import test.PHPParserSuperclass;
-
-/**
- * A Method declaration.
- * @author Matthieu Casanova
- */
-public class MethodDeclaration extends Statement implements OutlineableWithChildren {
-
-  /** The name of the method. */
-  public String name;
-  public Hashtable arguments;
-
-
-  public Statement[] statements;
-  public int bodyStart;
-  public int bodyEnd = -1;
-  /** Tell if the method is a class constructor. */
-  public boolean isConstructor;
-
-  /** The parent object. */
-  private Object parent;
-  /** The outlineable children (those will be in the node array too. */
-  private ArrayList children = new ArrayList();
-
-  /** Tell if the method returns a reference. */
-  public boolean reference;
-
-  private Position position;
-
-  public MethodDeclaration(final Object parent,
-                           final String name,
-                           final Hashtable arguments,
-                           final boolean reference,
-                           final int sourceStart,
-                           final int sourceEnd,
-                           final int bodyStart,
-                           final int bodyEnd) {
-    super(sourceStart, sourceEnd);
-    this.name = name;
-    this.arguments = arguments;
-    this.parent = parent;
-    this.reference = reference;
-    this.bodyStart = bodyStart;
-    this.bodyEnd = bodyEnd;
-    position = new Position(sourceStart, sourceEnd);
-  }
-
-  /**
-   * Return method into String, with a number of tabs
-   * @param tab the number of tabs
-   * @return the String containing the method
-   */
-  public String toString(final int tab) {
-    final StringBuffer buff = new StringBuffer(tabString(tab));
-    buff.append(toStringHeader());
-    buff.append(toStringStatements(tab + 1));
-    return buff.toString();
-  }
-
-  public String toStringHeader() {
-    return "function " + toString();
-  }
-
-  /**
-   * Return the statements of the method into Strings
-   * @param tab the number of tabs
-   * @return the String containing the statements
-   */
-  public String toStringStatements(final int tab) {
-    final StringBuffer buff = new StringBuffer(" {"); //$NON-NLS-1$
-    if (statements != null) {
-      for (int i = 0; i < statements.length; i++) {
-        buff.append("\n").append(statements[i].toString(tab)); //$NON-NLS-1$
-        if (!(statements[i] instanceof Block)) {
-          buff.append(";"); //$NON-NLS-1$
-        }
-      }
-    }
-    buff.append("\n").append(tabString(tab == 0 ? 0 : tab - 1)).append("}"); //$NON-NLS-2$ //$NON-NLS-1$
-    return buff.toString();
-  }
-
-  /**
-   * Get the image of a class.
-   * @return the image that represents a php class
-   */
-  public ImageDescriptor getImage() {
-    return PHPUiImages.DESC_FUN;
-  }
-
-  public void setParent(final Object parent) {
-    this.parent = parent;
-  }
-
-  public Object getParent() {
-    return parent;
-  }
-
-  public boolean add(final Outlineable o) {
-    return children.add(o);
-  }
-
-  public Outlineable get(final int index) {
-    return (Outlineable) children.get(index);
-  }
-
-  public int size() {
-    return children.size();
-  }
-
-  public String toString() {
-    final StringBuffer buff = new StringBuffer();
-    if (reference) {
-      buff.append("&");//$NON-NLS-1$
-    }
-    buff.append(name).append("(");//$NON-NLS-1$
-
-    if (arguments != null) {
-      final Enumeration values = arguments.elements();
-      int i = 0;
-      while (values.hasMoreElements()) {
-        final VariableDeclaration o = (VariableDeclaration) values.nextElement();
-        buff.append(o.toStringExpression());
-        if (i != (arguments.size() - 1)) {
-          buff.append(", "); //$NON-NLS-1$
-        }
-        i++;
-      }
-    }
-    buff.append(")"); //$NON-NLS-1$
-    return buff.toString();
-  }
-
-  public Position getPosition() {
-    return position;
-  }
-
-  public List getList() {
-    return children;
-  }
-
-  /** no outside variables. */
-  public List getOutsideVariable() {
-    return new ArrayList(1);
-  }
-
-  public List getModifiedVariable() {
-    return new ArrayList(1);
-  }
-
-  public List getUsedVariable() {
-    return new ArrayList(1);
-  }
-
-  /**
-   * Get global variables (not parameters).
-   * @return the variables from outside
-   */
-  public List getGlobalVariable() {
-    final ArrayList list = new ArrayList();
-
-    if (statements != null) {
-      for (int i = 0; i < statements.length; i++) {
-        list.addAll(statements[i].getOutsideVariable());
-      }
-    }
-    return list;
-  }
-
-  private List getParameters(final List list) {
-    if (arguments != null) {
-      final Enumeration vars = arguments.elements();
-      while (vars.hasMoreElements()) {
-        final VariableDeclaration variable = (VariableDeclaration) vars.nextElement();
-        list.add(new VariableUsage(variable.name(), variable.sourceStart));
-      }
-    }
-    return list;
-  }
-
-  /**
-   * get the modified variables.
-   * @return the variables from we change value
-   */
-  private List getAssignedVariableInCode() {
-    final ArrayList list = new ArrayList();
-    if (statements != null) {
-      for (int i = 0; i < statements.length; i++) {
-        list.addAll(statements[i].getModifiedVariable());
-      }
-    }
-    return list;
-  }
-
-  /**
-   * Get the variables used.
-   * @return the variables used
-   */
-  private List getUsedVariableInCode() {
-    final ArrayList list = new ArrayList();
-    if (statements != null) {
-      for (int i = 0; i < statements.length; i++) {
-        list.addAll(statements[i].getUsedVariable());
-      }
-    }
-    return list;
-  }
-
-  private boolean isVariableDeclaredBefore(List list, VariableUsage var) {
-    final String name = var.getName();
-    final int pos = var.getStartOffset();
-    for (int i = 0; i < list.size(); i++) {
-      VariableUsage variableUsage = (VariableUsage) list.get(i);
-      if (variableUsage.getName().equals(name) && variableUsage.getStartOffset() < pos) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  /** This method will analyze the code. */
-  public void analyzeCode() {
-    if (statements != null) {
-      for (int i = 0; i < statements.length; i++) {
-        statements[i].analyzeCode();
-
-      }
-    }
-
-    final List globalsVars = getGlobalVariable();
-    final List modifiedVars = getAssignedVariableInCode();
-    final List parameters = getParameters(new ArrayList());
-
-    final List declaredVars = new ArrayList(globalsVars.size() + modifiedVars.size());
-    declaredVars.addAll(globalsVars);
-    declaredVars.addAll(modifiedVars);
-    declaredVars.addAll(parameters);
-
-    final List usedVars = getUsedVariableInCode();
-    final List readOrWriteVars = new ArrayList(modifiedVars.size()+usedVars.size());
-    readOrWriteVars.addAll(modifiedVars);
-    readOrWriteVars.addAll(usedVars);
-
-    //look for used variables that were not declared before
-    findUnusedParameters(readOrWriteVars,parameters);
-    findUnknownUsedVars(usedVars, declaredVars);
-  }
-
-  /**
-   * This method will add a warning on all unused parameters.
-   * @param vars the used variable list
-   * @param parameters the declared variable list
-   */
-  private void findUnusedParameters(final List vars, final List parameters) {
-    for (int i = 0; i < parameters.size(); i++) {
-      VariableUsage param = ((VariableUsage)parameters.get(i));
-      if (!isVariableInList(param.getName(),vars)) {
-        try {
-          PHPParserSuperclass.setMarker("warning, the parameter "+param.getName() +" seems to be never used in your method",
-                                        param.getStartOffset(),
-                                        param.getStartOffset() + param.getName().length(),
-                                        PHPParserSuperclass.WARNING,
-                                        "");
-        } catch (CoreException e) {
-          PHPeclipsePlugin.log(e);
-        }
-      }
-    }
-  }
-
-  private boolean isVariableInList(final String name, final List list) {
-    for (int i = 0; i < list.size(); i++) {
-      if (((VariableUsage) list.get(i)).getName().equals(name)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  /**
-   * This method will add a warning on all used variables in a method that aren't declared before.
-   * @param usedVars the used variable list
-   * @param declaredVars the declared variable list
-   */
-  private void findUnknownUsedVars(final List usedVars, final List declaredVars) {
-    for (int i = 0; i < usedVars.size(); i++) {
-      VariableUsage variableUsage = (VariableUsage) usedVars.get(i);
-      if (variableUsage.getName().equals("this")) continue; // this is a special variable
-      if (!isVariableDeclaredBefore(declaredVars, variableUsage)) {
-        try {
-          PHPParserSuperclass.setMarker("warning, usage of a variable that seems to be unassigned yet : " + variableUsage.getName(),
-                                        variableUsage.getStartOffset(),
-                                        variableUsage.getStartOffset() + variableUsage.getName().length(),
-                                        PHPParserSuperclass.WARNING,
-                                        "");
-        } catch (CoreException e) {
-          PHPeclipsePlugin.log(e);
-        }
-      }
-    }
-  }
+import net.sourceforge.phpdt.core.compiler.CharOperation;
+import net.sourceforge.phpdt.internal.compiler.ASTVisitor;
+import net.sourceforge.phpdt.internal.compiler.CompilationResult;
+import net.sourceforge.phpdt.internal.compiler.flow.ExceptionHandlingFlowContext;
+import net.sourceforge.phpdt.internal.compiler.flow.FlowInfo;
+import net.sourceforge.phpdt.internal.compiler.flow.InitializationFlowContext;
+import net.sourceforge.phpdt.internal.compiler.lookup.ClassScope;
+import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
+import net.sourceforge.phpdt.internal.compiler.parser.UnitParser;
+import net.sourceforge.phpdt.internal.compiler.problem.AbortMethod;
+
+public class MethodDeclaration extends AbstractMethodDeclaration {
+
+       public TypeReference returnType;
+
+       public static final int FUNCTION_DEFINITION = 1;
+
+       public static final int METHOD_DEFINITION = 2;
+
+       public int type;
+
+       /**
+        * MethodDeclaration constructor comment.
+        */
+       public MethodDeclaration(CompilationResult compilationResult) {
+               super(compilationResult);
+       }
+
+       public void analyseCode(ClassScope classScope,
+                       InitializationFlowContext initializationContext, FlowInfo flowInfo) {
+
+               // starting of the code analysis for methods
+               if (ignoreFurtherInvestigation)
+                       return;
+               try {
+                       if (binding == null)
+                               return;
+
+                       if (this.binding.isPrivate() && !this.binding.isPrivateUsed()) {
+                               if (!classScope.referenceCompilationUnit().compilationResult
+                                               .hasSyntaxError()) {
+                                       scope.problemReporter().unusedPrivateMethod(this);
+                               }
+                       }
+
+                       // may be in a non necessary <clinit> for innerclass with static
+                       // final constant fields
+                       if (binding.isAbstract()) // || binding.isNative())
+                               return;
+
+                       ExceptionHandlingFlowContext methodContext = new ExceptionHandlingFlowContext(
+                                       initializationContext, this, binding.thrownExceptions,
+                                       scope, FlowInfo.DEAD_END);
+
+                       // propagate to statements
+                       if (statements != null) {
+                               boolean didAlreadyComplain = false;
+                               for (int i = 0, count = statements.length; i < count; i++) {
+                                       Statement stat;
+                                       if (!flowInfo.complainIfUnreachable((stat = statements[i]),
+                                                       scope, didAlreadyComplain)) {
+                                               flowInfo = stat.analyseCode(scope, methodContext,
+                                                               flowInfo);
+                                       } else {
+                                               didAlreadyComplain = true;
+                                       }
+                               }
+                       }
+                       // check for missing returning path
+                       TypeBinding returnType = binding.returnType;
+                       if ((returnType == VoidBinding) || isAbstract()) {
+                               this.needFreeReturn = flowInfo.isReachable();
+                       } else {
+                               if (flowInfo != FlowInfo.DEAD_END) {
+                                       scope.problemReporter().shouldReturn(returnType, this);
+                               }
+                       }
+               } catch (AbortMethod e) {
+                       this.ignoreFurtherInvestigation = true;
+               }
+       }
+
+       public void parseStatements(UnitParser parser,
+                       CompilationUnitDeclaration unit) {
+
+               // fill up the method body with statement
+               if (ignoreFurtherInvestigation)
+                       return;
+               parser.parse(this, unit);
+       }
+
+       public void resolveStatements() {
+
+               // ========= abort on fatal error =============
+               if (this.returnType != null && this.binding != null) {
+                       this.returnType.resolvedType = this.binding.returnType;
+                       // record the return type binding
+               }
+               // look if the name of the method is correct
+               if (binding != null && isTypeUseDeprecated(binding.returnType, scope))
+                       scope.problemReporter().deprecatedType(binding.returnType,
+                                       returnType);
+
+               if (scope != null) {
+                       if (CharOperation.equals(scope.enclosingSourceType().sourceName,
+                                       selector))
+                               scope.problemReporter().methodWithConstructorName(this);
+
+                       // by grammatical construction, interface methods are always
+                       // abstract
+                       if (!scope.enclosingSourceType().isInterface()) {
+
+                               // if a method has an semicolon body and is not declared as
+                               // abstract==>error
+                               // native methods may have a semicolon body
+                               // if ((modifiers & AccSemicolonBody) != 0) {
+                               // if ((modifiers & AccNative) == 0)
+                               // if ((modifiers & AccAbstract) == 0)
+                               // scope.problemReporter().methodNeedingAbstractModifier(this);
+                               // } else {
+                               // // the method HAS a body --> abstract native modifiers are
+                               // forbiden
+                               // if (((modifiers & AccNative) != 0) || ((modifiers &
+                               // AccAbstract) != 0))
+                               // scope.problemReporter().methodNeedingNoBody(this);
+                               // }
+                       }
+               }
+               super.resolveStatements();
+       }
+
+       public String returnTypeToString(int tab) {
+
+               if (returnType == null)
+                       return ""; //$NON-NLS-1$
+               return returnType.toString(tab) + " "; //$NON-NLS-1$
+       }
+
+       public void traverse(ASTVisitor visitor, ClassScope classScope) {
+
+               if (visitor.visit(this, classScope)) {
+                       if (returnType != null)
+                               returnType.traverse(visitor, scope);
+                       if (arguments != null) {
+                               int argumentLength = arguments.length;
+                               for (int i = 0; i < argumentLength; i++)
+                                       arguments[i].traverse(visitor, scope);
+                       }
+                       if (thrownExceptions != null) {
+                               int thrownExceptionsLength = thrownExceptions.length;
+                               for (int i = 0; i < thrownExceptionsLength; i++)
+                                       thrownExceptions[i].traverse(visitor, scope);
+                       }
+                       if (statements != null) {
+                               int statementsLength = statements.length;
+                               for (int i = 0; i < statementsLength; i++)
+                                       statements[i].traverse(visitor, scope);
+                       }
+               }
+               visitor.endVisit(this, classScope);
+       }
 }