DefinitionListTest (not working JUnit Test)
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpeclipse / internal / compiler / ast / MethodDeclaration.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2003 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials 
4  * are made available under the terms of the Common Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/cpl-v10.html
7  * 
8  * Contributors:
9  *     IBM Corporation - initial API and implementation
10  *******************************************************************************/
11 package net.sourceforge.phpeclipse.internal.compiler.ast;
12
13 import net.sourceforge.phpdt.core.compiler.CharOperation;
14 import net.sourceforge.phpdt.internal.compiler.CompilationResult;
15 import net.sourceforge.phpdt.internal.compiler.IAbstractSyntaxTreeVisitor;
16 import net.sourceforge.phpdt.internal.compiler.flow.ExceptionHandlingFlowContext;
17 import net.sourceforge.phpdt.internal.compiler.flow.FlowInfo;
18 import net.sourceforge.phpdt.internal.compiler.flow.InitializationFlowContext;
19 import net.sourceforge.phpdt.internal.compiler.lookup.ClassScope;
20 import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
21 import net.sourceforge.phpdt.internal.compiler.parser.UnitParser;
22 import net.sourceforge.phpdt.internal.compiler.problem.AbortMethod;
23
24 public class MethodDeclaration extends AbstractMethodDeclaration {
25
26   public TypeReference returnType;
27
28   /**
29    * MethodDeclaration constructor comment.
30    */
31   public MethodDeclaration(CompilationResult compilationResult) {
32     super(compilationResult);
33   }
34
35   public void analyseCode(ClassScope classScope, InitializationFlowContext initializationContext, FlowInfo flowInfo) {
36
37     // starting of the code analysis for methods
38     if (ignoreFurtherInvestigation)
39       return;
40     try {
41       if (binding == null)
42         return;
43
44       if (this.binding.isPrivate() && !this.binding.isPrivateUsed()) {
45         if (!classScope.referenceCompilationUnit().compilationResult.hasSyntaxError()) {
46           scope.problemReporter().unusedPrivateMethod(this);
47         }
48       }
49
50       // may be in a non necessary <clinit> for innerclass with static final constant fields
51       if (binding.isAbstract()) // || binding.isNative())
52         return;
53
54       ExceptionHandlingFlowContext methodContext =
55         new ExceptionHandlingFlowContext(initializationContext, this, binding.thrownExceptions, scope, FlowInfo.DEAD_END);
56
57       // propagate to statements
58       if (statements != null) {
59         boolean didAlreadyComplain = false;
60         for (int i = 0, count = statements.length; i < count; i++) {
61           Statement stat;
62           if (!flowInfo.complainIfUnreachable((stat = statements[i]), scope, didAlreadyComplain)) {
63             flowInfo = stat.analyseCode(scope, methodContext, flowInfo);
64           } else {
65             didAlreadyComplain = true;
66           }
67         }
68       }
69       // check for missing returning path
70       TypeBinding returnType = binding.returnType;
71       if ((returnType == VoidBinding) || isAbstract()) {
72         this.needFreeReturn = flowInfo.isReachable();
73       } else {
74         if (flowInfo != FlowInfo.DEAD_END) {
75           scope.problemReporter().shouldReturn(returnType, this);
76         }
77       }
78     } catch (AbortMethod e) {
79       this.ignoreFurtherInvestigation = true;
80     }
81   }
82
83   public void parseStatements(UnitParser parser, CompilationUnitDeclaration unit) {
84
85     //fill up the method body with statement
86     if (ignoreFurtherInvestigation)
87       return;
88     parser.parse(this, unit);
89   }
90
91   public void resolveStatements() {
92
93     // ========= abort on fatal error =============
94     if (this.returnType != null && this.binding != null) {
95       this.returnType.resolvedType = this.binding.returnType;
96       // record the return type binding
97     }
98     // look if the name of the method is correct
99     if (binding != null && isTypeUseDeprecated(binding.returnType, scope))
100       scope.problemReporter().deprecatedType(binding.returnType, returnType);
101
102     if (scope != null) {
103       if (CharOperation.equals(scope.enclosingSourceType().sourceName, selector))
104         scope.problemReporter().methodWithConstructorName(this);
105
106       // by grammatical construction, interface methods are always abstract
107       if (!scope.enclosingSourceType().isInterface()) {
108
109         // if a method has an semicolon body and is not declared as abstract==>error
110         // native methods may have a semicolon body 
111         //                      if ((modifiers & AccSemicolonBody) != 0) {
112         //                              if ((modifiers & AccNative) == 0)
113         //                                      if ((modifiers & AccAbstract) == 0)
114         //                                              scope.problemReporter().methodNeedingAbstractModifier(this);
115         //                      } else {
116         //                              // the method HAS a body --> abstract native modifiers are forbiden
117         //                              if (((modifiers & AccNative) != 0) || ((modifiers & AccAbstract) != 0))
118         //                                      scope.problemReporter().methodNeedingNoBody(this);
119         //                      }
120       }
121     }
122     super.resolveStatements();
123   }
124
125   public String returnTypeToString(int tab) {
126
127     if (returnType == null)
128       return ""; //$NON-NLS-1$
129     return returnType.toString(tab) + " "; //$NON-NLS-1$
130   }
131
132   public void traverse(IAbstractSyntaxTreeVisitor visitor, ClassScope classScope) {
133
134     if (visitor.visit(this, classScope)) {
135       if (returnType != null)
136         returnType.traverse(visitor, scope);
137       if (arguments != null) {
138         int argumentLength = arguments.length;
139         for (int i = 0; i < argumentLength; i++)
140           arguments[i].traverse(visitor, scope);
141       }
142       if (thrownExceptions != null) {
143         int thrownExceptionsLength = thrownExceptions.length;
144         for (int i = 0; i < thrownExceptionsLength; i++)
145           thrownExceptions[i].traverse(visitor, scope);
146       }
147       if (statements != null) {
148         int statementsLength = statements.length;
149         for (int i = 0; i < statementsLength; i++)
150           statements[i].traverse(visitor, scope);
151       }
152     }
153     visitor.endVisit(this, classScope);
154   }
155 }