net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/core/jdom/DOMMethod.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.phpdt.internal.core.jdom;
  12
  13 import net.sourceforge.phpdt.core.IJavaElement;
  14 import net.sourceforge.phpdt.core.IType;
  15 import net.sourceforge.phpdt.core.Signature;
  16 import net.sourceforge.phpdt.core.jdom.IDOMMethod;
  17 import net.sourceforge.phpdt.core.jdom.IDOMNode;
  18 import net.sourceforge.phpdt.internal.compiler.util.Util;
  19 import net.sourceforge.phpdt.internal.core.util.CharArrayBuffer;
  20 import net.sourceforge.phpdt.internal.core.util.CharArrayOps;
  21
  22 /**
  23  * DOMMethod provides an implementation of IDOMMethod.
  24  *
  25  * @see IDOMMethod
  26  * @see DOMNode
  27  */
  28
  29 class DOMMethod extends DOMMember implements IDOMMethod {
  30
  31         /**
  32          * Contains the return type of the method when the
  33          * return type has been altered from the contents
  34          * in the document, otherwise <code>null</code>.
  35          */
  36         protected String fReturnType;
  37
  38         /**
  39          * The original inclusive source range of the
  40          * method's return type in the document, or -1's
  41          * if no return type is present in the document.
  42          * If the return type of this method is qualified with
  43          * '[]' following the parameter list, this array has
  44          * four entries. In this case, the last two entries
  45          * of the array are the inclusive source range of
  46          * the array qualifiers.
  47          */
  48         protected int[]  fReturnTypeRange;
  49
  50         /**
  51          * Contains the textual representation of the method's
  52          * parameter list, including open and closing parentheses
  53          * when the parameters had been altered from the contents
  54          * in the document, otherwise <code>null</code>.
  55          */
  56         protected char[] fParameterList;
  57
  58         /**
  59          * The original inclusive source range of the
  60          * method's parameter list in the document.
  61          */
  62         protected int[]  fParameterRange;
  63
  64         /**
  65          * Contains the textual representation of the method's
  66          * exception list when the exceptions had been altered
  67          * from the contents in the document, otherwise
  68          * <code>null</code>. The exception list is a comment
  69          * delimited list of exceptions, not including the "throws"
  70          * keyword.
  71          */
  72         protected char[] fExceptionList;
  73
  74         /**
  75          * The original inclusive source range of the
  76          * method's exception list in the document.
  77          */
  78         protected int[]  fExceptionRange;
  79
  80         /**
  81          * Contains the method's body when the body has
  82          * been altered from the contents in the document,
  83          * otherwise <code>null</code>. The body includes everything
  84          * between and including the enclosing braces, and trailing
  85          * whitespace.
  86          */
  87         protected String fBody;
  88
  89         /**
  90          * The original inclusive source range of the
  91          * method's body.
  92          */
  93         protected int[]  fBodyRange;
  94
  95
  96         /**
  97          * Names of parameters in the method parameter list,
  98          * or <code>null</code> if the method has no parameters.
  99          */
 100         protected String[] fParameterNames;
 101
 102         /**
 103          * Types of parameters in the method parameter list,
 104          * or <code>null</code> if the method has no parameters.
 105          */
 106         protected String[] fParameterTypes;
 107
 108         /**
 109          * The exceptions the method throws, or <code>null</code>
 110          * if the method throws no exceptions.
 111          */
 112         protected String[] fExceptions;
 113
 114
 115 /**
 116  * Constructs an empty method node.
 117  */
 118 DOMMethod() {
 119
 120 }
 121 /**
 122  * Creates a new detailed METHOD document fragment on the given range of the document.
 123  *
 124  * @param document - the document containing this node's original contents
 125  * @param sourceRange - a two element array of integers describing the
 126  *              entire inclusive source range of this node within its document.
 127  *              Contents start on and include the character at the first position.
 128  *              Contents end on and include the character at the last position.
 129  *              An array of -1's indicates this node's contents do not exist
 130  *              in the document.
 131  * @param name - the identifier portion of the name of this node, or
 132  *              <code>null</code> if this node does not have a name
 133  * @param nameRange - a two element array of integers describing the
 134  *              entire inclusive source range of this node's name within its document,
 135  *              including any array qualifiers that might immediately follow the name
 136  *              or -1's if this node does not have a name.
 137  * @param commentRange - a two element array describing the comments that precede
 138  *              the member declaration. The first matches the start of this node's
 139  *              sourceRange, and the second is the new-line or first non-whitespace
 140  *              character following the last comment. If no comments are present,
 141  *              this array contains two -1's.
 142  * @param flags - an integer representing the modifiers for this member. The
 143  *              integer can be analyzed with org.eclipse.jdt.core.Flags
 144  * @param modifierRange - a two element array describing the location of
 145  *              modifiers for this member within its source range. The first integer
 146  *              is the first character of the first modifier for this member, and
 147  *              the second integer is the last whitespace character preceeding the
 148  *              next part of this member declaration. If there are no modifiers present
 149  *              in this node's source code (that is, package default visibility), this array
 150  *              contains two -1's.
 151  * @param isConstructor - true if the method is a contructor, otherwise false
 152  * @param returnType - the normalized return type of this method
 153  * @param returnTypeRange - a two element array describing the location of the
 154  *              return type within the method's source range. The first integer is is
 155  *              the position of the first character in the return type, and the second
 156  *              integer is the position of the last character in the return type.
 157  *              For constructors, the contents of this array are -1's.
 158  *              If the return type of this method is qualified with '[]' following the
 159  *              parameter list, this array has four entries. In this case, the last
 160  *              two entries of the array are the inclusive source range of the array
 161  *              qualifiers.
 162  * @param parameterTypes - an array of parameter types in the method declaration
 163  *              or <code>null</code> if the method has no parameters
 164  * @param parameterNames - an array of parameter names in the method declaration
 165  *              or <code>null</code> if the method has no parameters
 166  * @param parameterRange - a two element array describing the location of the
 167  *              parameter list in the method. The first integer is the location of the
 168  *              open parenthesis and the second integer is the location of the closing
 169  *              parenthesis.
 170  * @param exceptions - an array of the names of exceptions thrown by this method
 171  *              or <code>null</code> if the method throws no exceptions
 172  * @param exceptionRange - a two element array describing the location of the
 173  *              exception list in the method declaration. The first integer is the position
 174  *              of the first character in the first exception the method throws, and the
 175  *              second integer is the position of the last character of the last exception
 176  *              this method throws.
 177  * @param bodyRange - a two element array describing the location of the method's body.
 178  *              The first integer is the first character following the method's
 179  *              parameter list, or exception list (if present). The second integer is the location
 180  *              of the last character in the method's source range.
 181  */
 182 DOMMethod(char[] document, int[] sourceRange, String name, int[] nameRange, int[] commentRange, int flags, int[] modifierRange, boolean isConstructor, String returnType, int[] returnTypeRange, String[] parameterTypes, String[] parameterNames, int[] parameterRange, String[] exceptions, int[] exceptionRange, int[] bodyRange) {
 183         super(document, sourceRange, name, nameRange, commentRange, flags, modifierRange);
 184
 185         setMask(MASK_IS_CONSTRUCTOR, isConstructor);
 186         fReturnType= returnType;
 187         fReturnTypeRange= returnTypeRange;
 188         fParameterTypes= parameterTypes;
 189         fParameterNames= parameterNames;
 190         fParameterRange= parameterRange;
 191         fExceptionRange= exceptionRange;
 192         fExceptions= exceptions;
 193         setHasBody(true);
 194         fBodyRange= bodyRange;
 195         setMask(MASK_DETAILED_SOURCE_INDEXES, true);
 196
 197 }
 198 /**
 199  * Creates a new simple METHOD document fragment on the given range of the document.
 200  *
 201  * @param document - the document containing this node's original contents
 202  * @param sourceRange - a two element array of integers describing the
 203  *              entire inclusive source range of this node within its document.
 204  *              Contents start on and include the character at the first position.
 205  *              Contents end on and include the character at the last position.
 206  *              An array of -1's indicates this node's contents do not exist
 207  *              in the document.
 208  * @param name - the identifier portion of the name of this node, or
 209  *              <code>null</code> if this node does not have a name
 210  * @param nameRange - a two element array of integers describing the
 211  *              entire inclusive source range of this node's name within its document,
 212  *              including any array qualifiers that might immediately follow the name
 213  *              or -1's if this node does not have a name.
 214  * @param flags - an integer representing the modifiers for this member. The
 215  *              integer can be analyzed with org.eclipse.jdt.core.Flags
 216  * @param isConstructor - true if the method is a contructor, otherwise false
 217  * @param returnType - the normalized return type of this method
 218  * @param parameterTypes - an array of parameter types in the method declaration
 219  *              or <code>null</code> if the method has no parameters
 220  * @param parameterNames - an array of parameter names in the method declaration
 221  *              or <code>null</code> if the method has no parameters
 222  * @param exceptions - an array of the names of exceptions thrown by this method
 223  *              or <code>null</code> if the method throws no exceptions
 224  */
 225 DOMMethod(char[] document, int[] sourceRange, String name, int[] nameRange, int flags, boolean isConstructor, String returnType, String[] parameterTypes, String[] parameterNames, String[] exceptions) {
 226         this(document, sourceRange, name, nameRange, new int[] {-1, -1}, flags, new int[] {-1, -1}, isConstructor, returnType, new int[] {-1, -1}, parameterTypes, parameterNames, new int[] {-1, -1}, exceptions, new int[] {-1, -1}, new int[] {-1, -1});
 227         setMask(MASK_DETAILED_SOURCE_INDEXES, false);
 228 }
 229 /**
 230  * @see IDOMMethod#addException(String)
 231  */
 232 public void addException(String name) throws IllegalArgumentException {
 233         if (name == null) {
 234                 throw new IllegalArgumentException(Util.bind("dom.nullExceptionType")); //$NON-NLS-1$
 235         }
 236         if (fExceptions == null) {
 237                 fExceptions= new String[1];
 238                 fExceptions[0]= name;
 239         } else {
 240                 fExceptions= appendString(fExceptions, name);
 241         }
 242         setExceptions(fExceptions);
 243 }
 244 /**
 245  * @see IDOMMethod#addParameter(String, String)
 246  */
 247 public void addParameter(String type, String name) throws IllegalArgumentException {
 248         if (type == null) {
 249                 throw new IllegalArgumentException(Util.bind("dom.nullTypeParameter")); //$NON-NLS-1$
 250         }
 251         if (name == null) {
 252                 throw new IllegalArgumentException(Util.bind("dom.nullNameParameter")); //$NON-NLS-1$
 253         }
 254         if (fParameterNames == null) {
 255                 fParameterNames= new String[1];
 256                 fParameterNames[0]= name;
 257         } else {
 258                 fParameterNames= appendString(fParameterNames, name);
 259         }
 260         if (fParameterTypes == null) {
 261                 fParameterTypes= new String[1];
 262                 fParameterTypes[0]= type;
 263         } else {
 264                 fParameterTypes= appendString(fParameterTypes, type);
 265         }
 266         setParameters(fParameterTypes, fParameterNames);
 267 }
 268 /**
 269  * @see DOMMember#appendMemberBodyContents(CharArrayBuffer)
 270  */
 271 protected void appendMemberBodyContents(CharArrayBuffer buffer) {
 272         if (fBody != null) {
 273                 buffer.append(fBody);
 274         } else {
 275                 buffer.append(fDocument, fBodyRange[0], fBodyRange[1] + 1 - fBodyRange[0]);
 276         }
 277 }
 278 /**
 279  * @see DOMMember#appendMemberDeclarationContents(CharArrayBuffer)
 280  */
 281 protected void appendMemberDeclarationContents(CharArrayBuffer buffer) {
 282
 283         if (isConstructor()) {
 284                 buffer
 285                         .append(getConstructorName())
 286                         .append(fDocument, fNameRange[1] + 1, fParameterRange[0] - fNameRange[1] - 1);
 287         } else {
 288                 buffer.append(getReturnTypeContents());
 289                 if (fReturnTypeRange[0] >= 0) {
 290                         buffer.append(fDocument, fReturnTypeRange[1] + 1, fNameRange[0] - fReturnTypeRange[1] - 1);
 291                 } else {
 292                         buffer.append(' ');
 293                 }
 294                 buffer
 295                         .append(getNameContents())
 296                         .append(fDocument, fNameRange[1] + 1, fParameterRange[0] - fNameRange[1] - 1);
 297         }
 298         if (fParameterList != null) {
 299                 buffer.append(fParameterList);
 300         } else {
 301                 buffer.append(fDocument, fParameterRange[0], fParameterRange[1] + 1 - fParameterRange[0]);
 302         }
 303         int start;
 304         if (hasTrailingArrayQualifier() && isReturnTypeAltered()) {
 305                 start= fReturnTypeRange[3] + 1;
 306         } else {
 307                 start= fParameterRange[1] + 1;
 308         }
 309         if (fExceptions != null) {
 310                 // add 'throws' keyword
 311                 if (fExceptionRange[0] >= 0) {
 312                         buffer.append(fDocument, start, fExceptionRange[0] - start);
 313                 } else {
 314                         buffer.append(" throws "); //$NON-NLS-1$
 315                 }
 316                 // add exception list
 317                 if (fExceptionList != null) {
 318                         buffer.append(fExceptionList);
 319                         // add space before body
 320                         if (fExceptionRange[0] >= 0) {
 321                                 buffer.append(fDocument, fExceptionRange[1] + 1, fBodyRange[0] - fExceptionRange[1] - 1);
 322                         } else {
 323                                 buffer.append(fDocument, fParameterRange[1] + 1, fBodyRange[0] - fParameterRange[1] - 1);
 324                         }
 325                 } else {
 326                         // add list and space before body
 327                         buffer.append(fDocument, fExceptionRange[0], fBodyRange[0] - fExceptionRange[0]);
 328                 }
 329         } else {
 330                 // add space before body
 331                 if (fExceptionRange[0] >= 0) {
 332                         buffer.append(fDocument, fExceptionRange[1] + 1, fBodyRange[0] - fExceptionRange[1] - 1);
 333                 } else {
 334                         buffer.append(fDocument, start, fBodyRange[0] - start);
 335                 }
 336         }
 337
 338 }
 339 /**
 340  * @see DOMNode#appendSimpleContents(CharArrayBuffer)
 341  */
 342 protected void appendSimpleContents(CharArrayBuffer buffer) {
 343         // append eveything before my name
 344         buffer.append(fDocument, fSourceRange[0], fNameRange[0] - fSourceRange[0]);
 345         // append my name
 346         if (isConstructor()) {
 347                 buffer.append(getConstructorName());
 348         } else {
 349                 buffer.append(fName);
 350         }
 351         // append everything after my name
 352         buffer.append(fDocument, fNameRange[1] + 1, fSourceRange[1] - fNameRange[1]);
 353 }
 354 /**
 355  * @see IDOMMethod#getBody()
 356  */
 357 public String getBody() {
 358         becomeDetailed();
 359         if (hasBody()) {
 360                 if (fBody != null) {
 361                         return fBody;
 362                 } else {
 363                         return CharArrayOps.substring(fDocument, fBodyRange[0], fBodyRange[1] + 1 - fBodyRange[0]);
 364                 }
 365         } else {
 366                 return null;
 367         }
 368 }
 369 /**
 370  * Returns the simple name of the enclsoing type for this constructor.
 371  * If the constuctor is not currently enclosed in a type, the original
 372  * name of the constructor as found in the documnent is returned.
 373  */
 374 protected String getConstructorName() {
 375
 376         if (isConstructor()) {
 377                 if (getParent() != null) {
 378                         return getParent().getName();
 379                 } else {
 380                         // If there is no parent use the original name
 381                         return new String(getNameContents());
 382                 }
 383         } else {
 384                 return null;
 385         }
 386
 387 }
 388 /**
 389  * @see DOMNode#getDetailedNode()
 390  */
 391 //protected DOMNode getDetailedNode() {
 392 //      return (DOMNode)getFactory().createMethod(getContents());
 393 //}
 394 /**
 395  * @see IDOMMethod#getExceptions()
 396  */
 397 public String[] getExceptions() {
 398         return fExceptions;
 399 }
 400 /**
 401  * @see IDOMNode#getJavaElement
 402  */
 403 public IJavaElement getJavaElement(IJavaElement parent) throws IllegalArgumentException {
 404         if (parent.getElementType() == IJavaElement.TYPE) {
 405                 // translate parameter types to signatures
 406                 String[] sigs= null;
 407                 if (fParameterTypes != null) {
 408                         sigs= new String[fParameterTypes.length];
 409                         int i;
 410                         for (i= 0; i < fParameterTypes.length; i++) {
 411                                 sigs[i]= Signature.createTypeSignature(fParameterTypes[i].toCharArray(), false);
 412                         }
 413                 }
 414                 String name= null;
 415                 if (isConstructor()) {
 416                         name= getConstructorName();
 417                 } else {
 418                         name= getName();
 419                 }
 420                 return ((IType)parent).getMethod(name, sigs);
 421         } else {
 422                 throw new IllegalArgumentException(Util.bind("element.illegalParent")); //$NON-NLS-1$
 423         }
 424 }
 425 /**
 426  * @see DOMMember#getMemberDeclarationStartPosition()
 427  */
 428 protected int getMemberDeclarationStartPosition() {
 429         if (fReturnTypeRange[0] >= 0) {
 430                 return fReturnTypeRange[0];
 431         } else {
 432                 return fNameRange[0];
 433         }
 434 }
 435 /**
 436  * @see IDOMNode#getName()
 437  */
 438 public String getName() {
 439         if (isConstructor()) {
 440                 return null;
 441         } else {
 442                 return super.getName();
 443         }
 444 }
 445 /**
 446  * @see IDOMNode#getNodeType()
 447  */
 448 public int getNodeType() {
 449         return IDOMNode.METHOD;
 450 }
 451 /**
 452  * @see IDOMMethod#getParameterNames()
 453  */
 454 public String[] getParameterNames() {
 455         return fParameterNames;
 456 }
 457 /**
 458  * @see IDOMMethod#getParameterTypes()
 459  */
 460 public String[] getParameterTypes() {
 461         return fParameterTypes;
 462 }
 463 /**
 464  * @see IDOMMethod#getReturnType()
 465  */
 466 public String getReturnType() {
 467         if (isConstructor()) {
 468                 return null;
 469         } else {
 470                 return fReturnType;
 471         }
 472 }
 473 /**
 474  * Returns the source code to be used for this method's return type
 475  */
 476 protected char[] getReturnTypeContents() {
 477         if (isConstructor()) {
 478                 return null;
 479         } else {
 480                 if (isReturnTypeAltered()) {
 481                         return fReturnType.toCharArray();
 482                 } else {
 483                         return CharArrayOps.subarray(fDocument, fReturnTypeRange[0], fReturnTypeRange[1] + 1 - fReturnTypeRange[0]);
 484                 }
 485
 486         }
 487 }
 488 /**
 489  * Returns true if this method's return type has
 490  * array qualifiers ('[]') following the parameter list.
 491  */
 492 protected boolean hasTrailingArrayQualifier() {
 493         return fReturnTypeRange.length > 2;
 494 }
 495 /**
 496  * @see IDOMMethod#isConstructor()
 497  */
 498 public boolean isConstructor() {
 499         return getMask(MASK_IS_CONSTRUCTOR);
 500 }
 501 /**
 502  * Returns true if this method's return type has been altered
 503  * from the original document contents.
 504  */
 505 protected boolean isReturnTypeAltered() {
 506         return getMask(MASK_RETURN_TYPE_ALTERED);
 507 }
 508 /**
 509  * @see IDOMNode#isSigantureEqual(IDOMNode).
 510  *
 511  * <p>Two methods have equal signatures if there names are the same
 512  * and their parameter types are the same.
 513  */
 514 public boolean isSignatureEqual(IDOMNode node) {
 515         boolean ok= node.getNodeType() == getNodeType();
 516         if (ok) {
 517                 IDOMMethod method= (IDOMMethod)node;
 518                 ok = (isConstructor() && method.isConstructor()) ||
 519                         (!isConstructor() && !method.isConstructor());
 520                 if (ok && !isConstructor()) {
 521                         ok= getName().equals(method.getName());
 522                 }
 523                 if (!ok) {
 524                         return false;
 525                 }
 526
 527                 String[] types= method.getParameterTypes();
 528                 if (fParameterTypes == null || fParameterTypes.length == 0) {
 529                         // this method has no parameters
 530                         if (types == null || types.length == 0) {
 531                                 // the other method has no parameters either
 532                                 return true;
 533                         }
 534                 } else {
 535                         // this method has parameters
 536                         if (types == null || types.length == 0) {
 537                                 // the other method has no parameters
 538                                 return false;
 539                         }
 540                         if (fParameterTypes.length != types.length) {
 541                                 // the methods have a different number of parameters
 542                                 return false;
 543                         }
 544                         int i;
 545                         for (i= 0; i < types.length; i++) {
 546                                 if (!fParameterTypes[i].equals(types[i])) {
 547                                         return false;
 548                                 }
 549                         }
 550                         return true;
 551                 }
 552         }
 553         return false;
 554
 555 }
 556 /**
 557  * @see DOMNode
 558  */
 559 protected DOMNode newDOMNode() {
 560         return new DOMMethod();
 561 }
 562 /**
 563  * Offsets all the source indexes in this node by the given amount.
 564  */
 565 protected void offset(int offset) {
 566         super.offset(offset);
 567         offsetRange(fBodyRange, offset);
 568         offsetRange(fExceptionRange, offset);
 569         offsetRange(fParameterRange, offset);
 570         offsetRange(fReturnTypeRange, offset);
 571 }
 572 /**
 573  * @see IDOMMethod#setBody
 574  */
 575 public void setBody(String body) {
 576         becomeDetailed();
 577         fragment();
 578         fBody= body;
 579         setHasBody(body != null);
 580         if (!hasBody()) {
 581                 fBody= ";"+Util.LINE_SEPARATOR; //$NON-NLS-1$
 582         }
 583 }
 584 /**
 585  * Sets the end of the body range
 586  */
 587 void setBodyRangeEnd(int end) {
 588         fBodyRange[1] = end;
 589 }
 590 /**
 591  * @see IDOMMethod#setConstructor(boolean)
 592  */
 593 public void setConstructor(boolean b) {
 594         becomeDetailed();
 595         setMask(MASK_IS_CONSTRUCTOR, b);
 596         fragment();
 597 }
 598 /**
 599  * @see IDOMMethod#setExceptions(char[][])
 600  */
 601 public void setExceptions(String[] names) {
 602         becomeDetailed();
 603         if (names == null || names.length == 0) {
 604                 fExceptions= null;
 605         } else {
 606                 fExceptions= names;
 607                 CharArrayBuffer buffer = new CharArrayBuffer();
 608                 char[] comma = new char[] {',', ' '};
 609                 for (int i = 0, length = names.length; i < length; i++) {
 610                         if (i > 0)
 611                                 buffer.append(comma);
 612                         buffer.append(names[i]);
 613                 }
 614                 fExceptionList= buffer.getContents();
 615         }
 616         fragment();
 617 }
 618 /**
 619  * @see IDOMMethod#setName
 620  */
 621 public void setName(String name) {
 622         if (name == null) {
 623                 throw new IllegalArgumentException(Util.bind("element.nullName")); //$NON-NLS-1$
 624         } else {
 625                 super.setName(name);
 626         }
 627 }
 628 /**
 629  * @see IDOMMethod#setParameters(char[][], char[][])
 630  */
 631 public void setParameters(String[] types, String[] names) throws IllegalArgumentException {
 632         becomeDetailed();
 633         if (types== null || names == null) {
 634                 if (types == null && names == null) {
 635                         fParameterTypes= null;
 636                         fParameterNames= null;
 637                         fParameterList= new char[] {'(',')'};
 638                 } else {
 639                         throw new IllegalArgumentException(Util.bind("dom.mismatchArgNamesAndTypes")); //$NON-NLS-1$
 640                 }
 641         } else if (names.length != types.length) {
 642                 throw new IllegalArgumentException(Util.bind("dom.mismatchArgNamesAndTypes")); //$NON-NLS-1$
 643         } else if (names.length == 0) {
 644                 setParameters(null, null);
 645         } else {
 646                 fParameterNames= names;
 647                 fParameterTypes= types;
 648                 CharArrayBuffer parametersBuffer = new CharArrayBuffer();
 649                 parametersBuffer.append("("); //$NON-NLS-1$
 650                 char[] comma = new char[] {',', ' '};
 651                 for (int i = 0; i < names.length; i++) {
 652                         if (i > 0) {
 653                                 parametersBuffer.append(comma);
 654                         }
 655                         parametersBuffer
 656                                 .append(types[i])
 657                                 .append(' ')
 658                                 .append(names[i]);
 659                 }
 660                 parametersBuffer.append(')');
 661                 fParameterList= parametersBuffer.getContents();
 662         }
 663         fragment();
 664 }
 665 /**
 666  * @see IDOMMethod#setReturnType(char[])
 667  */
 668 public void setReturnType(String name) throws IllegalArgumentException {
 669         if (name == null) {
 670                 throw new IllegalArgumentException(Util.bind("dom.nullReturnType")); //$NON-NLS-1$
 671         }
 672         becomeDetailed();
 673         fragment();
 674         setReturnTypeAltered(true);
 675         fReturnType= name;
 676 }
 677 /**
 678  * Sets the state of this method declaration as having
 679  * the return type altered from the original document.
 680  */
 681 protected void setReturnTypeAltered(boolean typeAltered) {
 682         setMask(MASK_RETURN_TYPE_ALTERED, typeAltered);
 683 }
 684 /**
 685  */
 686 protected void setSourceRangeEnd(int end) {
 687         super.setSourceRangeEnd(end);
 688         fBodyRange[1]= end;
 689 }
 690 /**
 691  * @see DOMNode#shareContents(DOMNode)
 692  */
 693 protected void shareContents(DOMNode node) {
 694         super.shareContents(node);
 695         DOMMethod method= (DOMMethod)node;
 696         fBody= method.fBody;
 697         fBodyRange= rangeCopy(method.fBodyRange);
 698         fExceptionList= method.fExceptionList;
 699         fExceptionRange= rangeCopy(method.fExceptionRange);
 700         fExceptions= method.fExceptions;
 701         fParameterList= method.fParameterList;
 702         fParameterNames= method.fParameterNames;
 703         fParameterRange= rangeCopy(method.fParameterRange);
 704         fParameterTypes= method.fParameterTypes;
 705         fReturnType= method.fReturnType;
 706         fReturnTypeRange= rangeCopy(method.fReturnTypeRange);
 707 }
 708 /**
 709  * @see IDOMNode#toString()
 710  */
 711 public String toString() {
 712         if (isConstructor()) {
 713                 return "CONSTRUCTOR"; //$NON-NLS-1$
 714         } else {
 715                 return "METHOD: " + getName(); //$NON-NLS-1$
 716         }
 717 }
 718 }