/*******************************************************************************
 * 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.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);
	}
}
