X-Git-Url: http://git.phpeclipse.com diff --git a/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/ast/MethodDeclaration.java b/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/ast/MethodDeclaration.java index a7653b0..f1220ab 100644 --- a/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/ast/MethodDeclaration.java +++ b/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/ast/MethodDeclaration.java @@ -1,103 +1,332 @@ -/******************************************************************************* - * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. and others. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Common Public License v0.5 - * which accompanies this distribution, and is available at - * http://www.eclipse.org/legal/cpl-v05.html - * - * Contributors: - * IBM Corporation - initial API and implementation - ******************************************************************************/ package net.sourceforge.phpdt.internal.compiler.ast; -import net.sourceforge.phpdt.internal.compiler.CompilationResult; -import net.sourceforge.phpdt.internal.compiler.IAbstractSyntaxTreeVisitor; -import net.sourceforge.phpdt.internal.compiler.lookup.ClassScope; -import net.sourceforge.phpdt.internal.compiler.parser.Parser; -import net.sourceforge.phpdt.internal.compiler.util.CharOperation; - -public class MethodDeclaration extends AbstractMethodDeclaration { - - public TypeReference returnType; - - /** - * MethodDeclaration constructor comment. - */ - public MethodDeclaration(CompilationResult compilationResult) { - super(compilationResult); - } - - - public void parseStatements(Parser parser, CompilationUnitDeclaration unit) { - - //fill up the method body with statement - if (ignoreFurtherInvestigation) - return; - parser.parse(this, unit); - } - - public void resolveStatements(ClassScope upperScope) { - - // ========= abort on fatal error ============= - if (this.returnType != null && this.binding != null) { - this.returnType.binding = 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 (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(upperScope); - } - - public String returnTypeToString(int tab) { - - if (returnType == null) - return ""; //$NON-NLS-1$ - return returnType.toString(tab) + " "; //$NON-NLS-1$ - } - - public void traverse( - IAbstractSyntaxTreeVisitor 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); - } -} \ No newline at end of file +import net.sourceforge.phpdt.internal.compiler.ast.declarations.VariableUsage; +import net.sourceforge.phpdt.internal.compiler.parser.Outlineable; +import net.sourceforge.phpdt.internal.compiler.parser.OutlineableWithChildren; +import net.sourceforge.phpdt.internal.ui.PHPUiImages; +import net.sourceforge.phpeclipse.PHPeclipsePlugin; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.jface.resource.ImageDescriptor; +import org.eclipse.jface.text.Position; +import test.PHPParserSuperclass; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; + +/** + * A Method declaration. + * + * @author Matthieu Casanova + */ +public final class MethodDeclaration extends Statement implements OutlineableWithChildren { + + /** The name of the method. */ + public final String name; + private final ArrayList arguments; + + + public Statement[] statements; + private final int bodyStart; + private 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 final ArrayList children = new ArrayList(); + + /** Tell if the method returns a reference. */ + private final boolean reference; + + private final Position position; + + public MethodDeclaration(final Object parent, + final String name, + final ArrayList 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(); + } + + private 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 + */ + private 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) { + for (int i = 0; i < arguments.size(); i++) { + final VariableDeclaration o = (VariableDeclaration) arguments.get(i); + buff.append(o.toStringExpression()); + if (i != (arguments.size() - 1)) { + buff.append(", "); //$NON-NLS-1$ + } + } + } + buff.append(")"); //$NON-NLS-1$ + return buff.toString(); + } + + public Position getPosition() { + return position; + } + + public List getList() { + return children; + } + + /** + * Get the variables from outside (parameters, globals ...) + * + * @param list the list where we will put variables + */ + public void getOutsideVariable(final List list) {} + + /** + * get the modified variables. + * + * @param list the list where we will put variables + */ + public void getModifiedVariable(final List list) {} + + /** + * This method will analyze the code. + * + * @param list the list where we will put variables + */ + public void getUsedVariable(final List list) {} + + /** + * Get global variables (not parameters). + */ + private void getGlobalVariable(final List list) { + if (statements != null) { + for (int i = 0; i < statements.length; i++) { + statements[i].getOutsideVariable(list); + } + } + } + + private void getParameters(final List list) { + if (arguments != null) { + for (int i = 0; i < arguments.size(); i++) { + final VariableDeclaration variable = (VariableDeclaration) arguments.get(i); + list.add(new VariableUsage(variable.name(), variable.sourceStart)); + } + } + } + + /** + * get the modified variables. + */ + private void getAssignedVariableInCode(final List list) { + if (statements != null) { + for (int i = 0; i < statements.length; i++) { + statements[i].getModifiedVariable(list); + } + } + } + + /** + * Get the variables used. + */ + private void getUsedVariableInCode(final List list) { + if (statements != null) { + for (int i = 0; i < statements.length; i++) { + statements[i].getUsedVariable(list); + } + } + } + + private static boolean isVariableDeclaredBefore(final List list, final VariableUsage var) { + final String name = var.getName(); + final int pos = var.getStartOffset(); + for (int i = 0; i < list.size(); i++) { + final 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 = new ArrayList(); + getGlobalVariable(globalsVars); + final List modifiedVars = new ArrayList(); + getAssignedVariableInCode(modifiedVars); + final List parameters = new ArrayList(arguments.size()); + getParameters(parameters); + + final List declaredVars = new ArrayList(globalsVars.size() + modifiedVars.size()); + declaredVars.addAll(globalsVars); + declaredVars.addAll(modifiedVars); + declaredVars.addAll(parameters); + + final List usedVars = new ArrayList(); + getUsedVariableInCode(usedVars); + 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 static void findUnusedParameters(final List vars, final List parameters) { + for (int i = 0; i < parameters.size(); i++) { + final 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); + } + } + } + } + + /** + * Tell if the list of VariableUsage contains a variable named by the name given. + * + * @param name the variable name + * @param list the list of VariableUsage + * @return true if the variable is in the list false otherwise + */ + private static 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 static void findUnknownUsedVars(final List usedVars, final List declaredVars) { + final HashSet list = new HashSet(usedVars.size()); + for (int i = 0; i < usedVars.size(); i++) { + final VariableUsage variableUsage = (VariableUsage) usedVars.get(i); + if ("this".equals(variableUsage.getName())) continue; // this is a special variable + if (!list.contains(variableUsage.getName()) && !isVariableDeclaredBefore(declaredVars, variableUsage)) { + list.add(variableUsage.getName()); + 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); + } + } + } + } +}