1 /* 2 * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package jdk.nashorn.internal.ir; 27 28 import java.util.Collections; 29 import java.util.EnumSet; 30 import java.util.HashSet; 31 import java.util.List; 32 import java.util.Set; 33 import jdk.nashorn.internal.codegen.CompileUnit; 34 import jdk.nashorn.internal.codegen.Compiler; 35 import jdk.nashorn.internal.codegen.CompilerConstants; 36 import jdk.nashorn.internal.codegen.Namespace; 37 import jdk.nashorn.internal.codegen.types.Type; 38 import jdk.nashorn.internal.ir.annotations.Ignore; 39 import jdk.nashorn.internal.ir.annotations.Immutable; 40 import jdk.nashorn.internal.ir.visitor.NodeVisitor; 41 import jdk.nashorn.internal.runtime.ScriptFunction; 42 import jdk.nashorn.internal.runtime.Source; 43 import jdk.nashorn.internal.runtime.UserAccessorProperty; 44 import jdk.nashorn.internal.runtime.linker.LinkerCallSite; 45 46 /** 47 * IR representation for function (or script.) 48 */ 49 @Immutable 50 public final class FunctionNode extends LexicalContextExpression implements Flags<FunctionNode> { 51 52 /** Type used for all FunctionNodes */ 53 public static final Type FUNCTION_TYPE = Type.typeFor(ScriptFunction.class); 54 55 /** Function kinds */ 56 public enum Kind { 57 /** a normal function - nothing special */ 58 NORMAL, 59 /** a script function */ 60 SCRIPT, 61 /** a getter, @see {@link UserAccessorProperty} */ 62 GETTER, 63 /** a setter, @see {@link UserAccessorProperty} */ 64 SETTER 65 } 66 67 /** Compilation states available */ 68 public enum CompilationState { 69 /** compiler is ready */ 70 INITIALIZED, 71 /** method has been parsed */ 72 PARSED, 73 /** method has been parsed */ 74 PARSE_ERROR, 75 /** constant folding pass */ 76 CONSTANT_FOLDED, 77 /** method has been lowered */ 78 LOWERED, 79 /** method hass been attributed */ 80 ATTR, 81 /** method has been split */ 82 SPLIT, 83 /** method has had its types finalized */ 84 FINALIZED, 85 /** method has been emitted to bytecode */ 86 EMITTED 87 } 88 /** Source of entity. */ 89 private final Source source; 90 91 /** External function identifier. */ 92 @Ignore 93 private final IdentNode ident; 94 95 /** Parsed version of functionNode */ 96 @Ignore 97 private final FunctionNode snapshot; 98 99 /** The body of the function node */ 100 private final Block body; 101 102 /** Internal function name. */ 103 private final String name; 104 105 /** Compilation unit. */ 106 private final CompileUnit compileUnit; 107 108 /** Function kind. */ 109 private final Kind kind; 110 111 /** List of parameters. */ 112 private final List<IdentNode> parameters; 113 114 /** First token of function. **/ 115 private final long firstToken; 116 117 /** Last token of function. **/ 118 private final long lastToken; 119 120 /** Declared symbols in this function node */ 121 @Ignore 122 private final Set<Symbol> declaredSymbols; 123 124 /** Method's namespace. */ 125 private final Namespace namespace; 126 127 /** Current compilation state */ 128 @Ignore 129 private final EnumSet<CompilationState> compilationState; 130 131 @Ignore 132 private final Compiler.Hints hints; 133 134 /** Properties of this object assigned in this function */ 135 @Ignore 136 private HashSet<String> thisProperties; 137 138 /** Function flags. */ 139 private final int flags; 140 141 private final int lineNumber; 142 143 /** Is anonymous function flag. */ 144 public static final int IS_ANONYMOUS = 1 << 0; 145 146 /** Is the function created in a function declaration (as opposed to a function expression) */ 147 public static final int IS_DECLARED = 1 << 1; 148 149 /** is this a strict mode function? */ 150 public static final int IS_STRICT = 1 << 2; 151 152 /** Does the function use the "arguments" identifier ? */ 153 public static final int USES_ARGUMENTS = 1 << 3; 154 155 /** Has this node been split because it was too large? */ 156 public static final int IS_SPLIT = 1 << 4; 157 158 /** Does the function call eval? If it does, then all variables in this function might be get/set by it and it can 159 * introduce new variables into this function's scope too.*/ 160 public static final int HAS_EVAL = 1 << 5; 161 162 /** Does a nested function contain eval? If it does, then all variables in this function might be get/set by it. */ 163 public static final int HAS_NESTED_EVAL = 1 << 6; 164 165 /** Does this function have any blocks that create a scope? This is used to determine if the function needs to 166 * have a local variable slot for the scope symbol. */ 167 public static final int HAS_SCOPE_BLOCK = 1 << 7; 168 169 /** 170 * Flag this function as one that defines the identifier "arguments" as a function parameter or nested function 171 * name. This precludes it from needing to have an Arguments object defined as "arguments" local variable. Note that 172 * defining a local variable named "arguments" still requires construction of the Arguments object (see 173 * ECMAScript 5.1 Chapter 10.5). 174 * @see #needsArguments() 175 */ 176 public static final int DEFINES_ARGUMENTS = 1 << 8; 177 178 /** Does this function or any of its descendants use variables from an ancestor function's scope (incl. globals)? */ 179 public static final int USES_ANCESTOR_SCOPE = 1 << 9; 180 181 /** Is this function lazily compiled? */ 182 public static final int IS_LAZY = 1 << 10; 183 184 /** Does this function have lazy, yet uncompiled children */ 185 public static final int HAS_LAZY_CHILDREN = 1 << 11; 186 187 /** Does this function have lazy, yet uncompiled children */ 188 public static final int IS_PROGRAM = 1 << 12; 189 190 /** Does this function have nested declarations? */ 191 public static final int HAS_FUNCTION_DECLARATIONS = 1 << 13; 192 193 /** Can this function be specialized? */ 194 public static final int CAN_SPECIALIZE = 1 << 14; 195 196 /** Does this function or any nested functions contain an eval? */ 197 private static final int HAS_DEEP_EVAL = HAS_EVAL | HAS_NESTED_EVAL; 198 199 /** Does this function need to store all its variables in scope? */ 200 private static final int HAS_ALL_VARS_IN_SCOPE = HAS_DEEP_EVAL | IS_SPLIT | HAS_LAZY_CHILDREN; 201 202 /** Does this function potentially need "arguments"? Note that this is not a full test, as further negative check of REDEFINES_ARGS is needed. */ 203 private static final int MAYBE_NEEDS_ARGUMENTS = USES_ARGUMENTS | HAS_EVAL; 204 205 /** Does this function need the parent scope? It needs it if either it or its descendants use variables from it, or have a deep eval. 206 * We also pessimistically need a parent scope if we have lazy children that have not yet been compiled */ 207 private static final int NEEDS_PARENT_SCOPE = USES_ANCESTOR_SCOPE | HAS_DEEP_EVAL | HAS_LAZY_CHILDREN; 208 209 /** What is the return type of this function? */ 210 private Type returnType = Type.UNKNOWN; 211 212 /** 213 * Constructor 214 * 215 * @param source the source 216 * @param lineNumber line number 217 * @param token token 218 * @param finish finish 219 * @param firstToken first token of the funtion node (including the function declaration) 220 * @param namespace the namespace 221 * @param ident the identifier 222 * @param name the name of the function 223 * @param parameters parameter list 224 * @param kind kind of function as in {@link FunctionNode.Kind} 225 * @param flags initial flags 226 */ 227 public FunctionNode( 228 final Source source, 229 final int lineNumber, 230 final long token, 231 final int finish, 232 final long firstToken, 233 final Namespace namespace, 234 final IdentNode ident, 235 final String name, 236 final List<IdentNode> parameters, 237 final FunctionNode.Kind kind, 238 final int flags) { 239 super(token, finish); 240 241 this.source = source; 242 this.lineNumber = lineNumber; 243 this.ident = ident; 244 this.name = name; 245 this.kind = kind; 246 this.parameters = parameters; 247 this.firstToken = firstToken; 248 this.lastToken = token; 249 this.namespace = namespace; 250 this.compilationState = EnumSet.of(CompilationState.INITIALIZED); 251 this.declaredSymbols = new HashSet<>(); 252 this.flags = flags; 253 this.compileUnit = null; 254 this.body = null; 255 this.snapshot = null; 256 this.hints = null; 257 } 258 259 private FunctionNode( 260 final FunctionNode functionNode, 261 final long lastToken, 262 final int flags, 263 final String name, 264 final Type returnType, 265 final CompileUnit compileUnit, 266 final EnumSet<CompilationState> compilationState, 267 final Block body, 268 final List<IdentNode> parameters, 269 final FunctionNode snapshot, 270 final Compiler.Hints hints) { 271 super(functionNode); 272 this.lineNumber = functionNode.lineNumber; 273 this.flags = flags; 274 this.name = name; 275 this.returnType = returnType; 276 this.compileUnit = compileUnit; 277 this.lastToken = lastToken; 278 this.compilationState = compilationState; 279 this.body = body; 280 this.parameters = parameters; 281 this.snapshot = snapshot; 282 this.hints = hints; 283 284 // the fields below never change - they are final and assigned in constructor 285 this.source = functionNode.source; 286 this.ident = functionNode.ident; 287 this.namespace = functionNode.namespace; 288 this.declaredSymbols = functionNode.declaredSymbols; 289 this.kind = functionNode.kind; 290 this.firstToken = functionNode.firstToken; 291 this.thisProperties = functionNode.thisProperties; 292 } 293 294 @Override 295 public Node accept(final LexicalContext lc, final NodeVisitor<? extends LexicalContext> visitor) { 296 if (visitor.enterFunctionNode(this)) { 297 return visitor.leaveFunctionNode(setBody(lc, (Block)body.accept(visitor))); 298 } 299 return this; 300 } 301 302 /** 303 * Get the source for this function 304 * @return the source 305 */ 306 public Source getSource() { 307 return source; 308 } 309 310 /** 311 * Returns the line number. 312 * @return the line number. 313 */ 314 public int getLineNumber() { 315 return lineNumber; 316 } 317 318 /** 319 * Get the version of this function node's code as it looked upon construction 320 * i.e typically parsed and nothing else 321 * @return initial version of function node 322 */ 323 public FunctionNode getSnapshot() { 324 return snapshot; 325 } 326 327 /** 328 * Throw away the snapshot, if any, to save memory. Used when heuristic 329 * determines that a method is not worth specializing 330 * 331 * @param lc lexical context 332 * @return new function node if a snapshot was present, now with snapsnot null 333 */ 334 public FunctionNode clearSnapshot(final LexicalContext lc) { 335 if (this.snapshot == null) { 336 return this; 337 } 338 return Node.replaceInLexicalContext(lc, this, new FunctionNode(this, lastToken, flags, name, returnType, compileUnit, compilationState, body, parameters, null, hints)); 339 } 340 341 /** 342 * Take a snapshot of this function node at a given point in time 343 * and store it in the function node 344 * @param lc lexical context 345 * @return function node 346 */ 347 public FunctionNode snapshot(final LexicalContext lc) { 348 if (this.snapshot == this) { 349 return this; 350 } 351 if (isProgram() || parameters.isEmpty()) { 352 return this; //never specialize anything that won't be recompiled 353 } 354 return Node.replaceInLexicalContext(lc, this, new FunctionNode(this, lastToken, flags, name, returnType, compileUnit, compilationState, body, parameters, this, hints)); 355 } 356 357 /** 358 * Can this function node be regenerated with more specific type args? 359 * @return true if specialization is possible 360 */ 361 public boolean canSpecialize() { 362 return snapshot != null && getFlag(CAN_SPECIALIZE); 363 } 364 365 /** 366 * Get the compilation state of this function 367 * @return the compilation state 368 */ 369 public EnumSet<CompilationState> getState() { 370 return compilationState; 371 } 372 373 /** 374 * Check whether this FunctionNode has reached a give CompilationState. 375 * 376 * @param state the state to check for 377 * @return true of the node is in the given state 378 */ 379 public boolean hasState(final EnumSet<CompilationState> state) { 380 return compilationState.equals(state); 381 } 382 383 /** 384 * Check whether the state of this FunctionNode contains a given compilation 385 * state. 386 * 387 * A node can be in many states at once, e.g. both lowered and initialized. 388 * To check for an exact state, use {FunctionNode{@link #hasState(EnumSet)} 389 * 390 * @param state state to check for 391 * @return true if state is present in the total compilation state of this FunctionNode 392 */ 393 public boolean hasState(final CompilationState state) { 394 return compilationState.contains(state); 395 } 396 397 /** 398 * Add a state to the total CompilationState of this node, e.g. if 399 * FunctionNode has been lowered, the compiler will add 400 * {@code CompilationState#LOWERED} to the state vector 401 * 402 * @param lc lexical context 403 * @param state {@link CompilationState} to add 404 * @return function node or a new one if state was changed 405 */ 406 public FunctionNode setState(final LexicalContext lc, final CompilationState state) { 407 if (this.compilationState.contains(state)) { 408 return this; 409 } 410 final EnumSet<CompilationState> newState = EnumSet.copyOf(this.compilationState); 411 newState.add(state); 412 return Node.replaceInLexicalContext(lc, this, new FunctionNode(this, lastToken, flags, name, returnType, compileUnit, newState, body, parameters, snapshot, hints)); 413 } 414 415 /** 416 * Get any compiler hints that may associated with the function 417 * @return compiler hints 418 */ 419 public Compiler.Hints getHints() { 420 return this.hints == null ? Compiler.Hints.EMPTY : hints; 421 } 422 423 /** 424 * Set compiler hints for this function 425 * @param lc lexical context 426 * @param hints compiler hints 427 * @return new function if hints changed 428 */ 429 public FunctionNode setHints(final LexicalContext lc, final Compiler.Hints hints) { 430 if (this.hints == hints) { 431 return this; 432 } 433 return Node.replaceInLexicalContext(lc, this, new FunctionNode(this, lastToken, flags, name, returnType, compileUnit, compilationState, body, parameters, snapshot, hints)); 434 } 435 436 /** 437 * Create a unique name in the namespace of this FunctionNode 438 * @param base prefix for name 439 * @return base if no collision exists, otherwise a name prefix with base 440 */ 441 public String uniqueName(final String base) { 442 return namespace.uniqueName(base); 443 } 444 445 446 @Override 447 public void toString(final StringBuilder sb) { 448 sb.append('['); 449 sb.append(returnType); 450 sb.append(']'); 451 sb.append(' '); 452 453 sb.append("function"); 454 455 if (ident != null) { 456 sb.append(' '); 457 ident.toString(sb); 458 } 459 460 sb.append('('); 461 boolean first = true; 462 463 for (final IdentNode parameter : parameters) { 464 if (!first) { 465 sb.append(", "); 466 } else { 467 first = false; 468 } 469 470 parameter.toString(sb); 471 } 472 473 sb.append(')'); 474 } 475 476 @Override 477 public boolean getFlag(final int flag) { 478 return (flags & flag) != 0; 479 } 480 481 @Override 482 public FunctionNode setFlags(final LexicalContext lc, int flags) { 483 if (this.flags == flags) { 484 return this; 485 } 486 return Node.replaceInLexicalContext(lc, this, new FunctionNode(this, lastToken, flags, name, returnType, compileUnit, compilationState, body, parameters, snapshot, hints)); 487 } 488 489 @Override 490 public FunctionNode clearFlag(final LexicalContext lc, final int flag) { 491 return setFlags(lc, flags & ~flag); 492 } 493 494 @Override 495 public FunctionNode setFlag(final LexicalContext lc, final int flag) { 496 return setFlags(lc, flags | flag); 497 } 498 499 /** 500 * Returns true if the function is the top-level program. 501 * @return True if this function node represents the top-level program. 502 */ 503 public boolean isProgram() { 504 return getFlag(IS_PROGRAM); 505 } 506 507 /** 508 * Should this function node be lazily code generated, i.e. first at link time 509 * @return true if lazy 510 */ 511 public boolean isLazy() { 512 return getFlag(IS_LAZY); 513 } 514 515 /** 516 * Check if the {@code eval} keyword is used in this function 517 * 518 * @return true if {@code eval} is used 519 */ 520 public boolean hasEval() { 521 return getFlag(HAS_EVAL); 522 } 523 524 /** 525 * Get the first token for this function 526 * @return the first token 527 */ 528 public long getFirstToken() { 529 return firstToken; 530 } 531 532 /** 533 * Check whether this function has nested function declarations 534 * @return true if nested function declarations exist 535 */ 536 public boolean hasDeclaredFunctions() { 537 return getFlag(HAS_FUNCTION_DECLARATIONS); 538 } 539 540 /** 541 * Check if this function's generated Java method needs a {@code callee} parameter. Functions that need access to 542 * their parent scope, functions that reference themselves, and non-strict functions that need an Arguments object 543 * (since it exposes {@code arguments.callee} property) will need to have a callee parameter. We also return true 544 * for split functions to make sure symbols slots are the same in the main and split methods. 545 * 546 * @return true if the function's generated Java method needs a {@code callee} parameter. 547 */ 548 public boolean needsCallee() { 549 return needsParentScope() || needsSelfSymbol() || isSplit() || (needsArguments() && !isStrict()); 550 } 551 552 /** 553 * Get the identifier for this function, this is its symbol. 554 * @return the identifier as an IdentityNode 555 */ 556 public IdentNode getIdent() { 557 return ident; 558 } 559 560 /** 561 * Return a set of symbols declared in this function node. This 562 * is only relevant after Attr, otherwise it will be an empty 563 * set as no symbols have been introduced 564 * @return set of declared symbols in function 565 */ 566 public Set<Symbol> getDeclaredSymbols() { 567 return Collections.unmodifiableSet(declaredSymbols); 568 } 569 570 /** 571 * Add a declared symbol to this function node 572 * @param symbol symbol that is declared 573 */ 574 public void addDeclaredSymbol(final Symbol symbol) { 575 declaredSymbols.add(symbol); 576 } 577 578 /** 579 * Get the function body 580 * @return the function body 581 */ 582 public Block getBody() { 583 return body; 584 } 585 586 /** 587 * Reset the function body 588 * @param lc lexical context 589 * @param body new body 590 * @return new function node if body changed, same if not 591 */ 592 public FunctionNode setBody(final LexicalContext lc, final Block body) { 593 if(this.body == body) { 594 return this; 595 } 596 return Node.replaceInLexicalContext(lc, this, new FunctionNode(this, lastToken, flags | (body.needsScope() ? FunctionNode.HAS_SCOPE_BLOCK : 0), name, returnType, compileUnit, compilationState, body, parameters, snapshot, hints)); 597 } 598 599 /** 600 * Does this function's method needs to be variable arity (gather all script-declared parameters in a final 601 * {@code Object[]} parameter. Functions that need to have the "arguments" object as well as functions that simply 602 * declare too many arguments for JVM to handle with fixed arity will need to be variable arity. 603 * @return true if the Java method in the generated code that implements this function needs to be variable arity. 604 * @see #needsArguments() 605 * @see LinkerCallSite#ARGLIMIT 606 */ 607 public boolean isVarArg() { 608 return needsArguments() || parameters.size() > LinkerCallSite.ARGLIMIT; 609 } 610 611 /** 612 * Returns true if this function needs to have an Arguments object defined as a local variable named "arguments". 613 * Functions that use "arguments" as identifier and don't define it as a name of a parameter or a nested function 614 * (see ECMAScript 5.1 Chapter 10.5), as well as any function that uses eval or with, or has a nested function that 615 * does the same, will have an "arguments" object. Also, if this function is a script, it will not have an 616 * "arguments" object, because it does not have local variables; rather the Global object will have an explicit 617 * "arguments" property that provides command-line arguments for the script. 618 * @return true if this function needs an arguments object. 619 */ 620 public boolean needsArguments() { 621 // uses "arguments" or calls eval, but it does not redefine "arguments", and finally, it's not a script, since 622 // for top-level script, "arguments" is picked up from Context by Global.init() instead. 623 return getFlag(MAYBE_NEEDS_ARGUMENTS) && !getFlag(DEFINES_ARGUMENTS) && !isProgram(); 624 } 625 626 /** 627 * Returns true if this function needs access to its parent scope. Functions referencing variables outside their 628 * scope (including global variables), as well as functions that call eval or have a with block, or have nested 629 * functions that call eval or have a with block, will need a parent scope. Top-level script functions also need a 630 * parent scope since they might be used from within eval, and eval will need an externally passed scope. 631 * @return true if the function needs parent scope. 632 */ 633 public boolean needsParentScope() { 634 return getFlag(NEEDS_PARENT_SCOPE) || isProgram(); 635 } 636 637 /** 638 * Register a property assigned to the this object in this function. 639 * @param key the property name 640 */ 641 public void addThisProperty(final String key) { 642 if (thisProperties == null) { 643 thisProperties = new HashSet<>(); 644 } 645 thisProperties.add(key); 646 } 647 648 /** 649 * Get the number of properties assigned to the this object in this function. 650 * @return number of properties 651 */ 652 public int countThisProperties() { 653 return thisProperties == null ? 0 : thisProperties.size(); 654 } 655 656 /** 657 * Returns true if any of the blocks in this function create their own scope. 658 * @return true if any of the blocks in this function create their own scope. 659 */ 660 public boolean hasScopeBlock() { 661 return getFlag(HAS_SCOPE_BLOCK); 662 } 663 664 /** 665 * Return the kind of this function 666 * @see FunctionNode.Kind 667 * @return the kind 668 */ 669 public Kind getKind() { 670 return kind; 671 } 672 673 /** 674 * Return the last token for this function's code 675 * @return last token 676 */ 677 public long getLastToken() { 678 return lastToken; 679 } 680 681 /** 682 * Set the last token for this function's code 683 * @param lc lexical context 684 * @param lastToken the last token 685 * @return function node or a new one if state was changed 686 */ 687 public FunctionNode setLastToken(final LexicalContext lc, final long lastToken) { 688 if (this.lastToken == lastToken) { 689 return this; 690 } 691 return Node.replaceInLexicalContext(lc, this, new FunctionNode(this, lastToken, flags, name, returnType, compileUnit, compilationState, body, parameters, snapshot, hints)); 692 } 693 694 /** 695 * Get the name of this function 696 * @return the name 697 */ 698 public String getName() { 699 return name; 700 } 701 702 703 /** 704 * Set the internal name for this function 705 * @param lc lexical context 706 * @param name new name 707 * @return new function node if changed, otherwise the same 708 */ 709 public FunctionNode setName(final LexicalContext lc, final String name) { 710 if (this.name.equals(name)) { 711 return this; 712 } 713 return Node.replaceInLexicalContext(lc, this, new FunctionNode(this, lastToken, flags, name, returnType, compileUnit, compilationState, body, parameters, snapshot, hints)); 714 } 715 716 /** 717 * Check if this function should have all its variables in its own scope. Scripts, split sub-functions, and 718 * functions having with and/or eval blocks are such. 719 * 720 * @return true if all variables should be in scope 721 */ 722 public boolean allVarsInScope() { 723 return isProgram() || getFlag(HAS_ALL_VARS_IN_SCOPE); 724 } 725 726 /** 727 * Checks if this function is a sub-function generated by splitting a larger one 728 * 729 * @return true if this function is split from a larger one 730 */ 731 public boolean isSplit() { 732 return getFlag(IS_SPLIT); 733 } 734 735 /** 736 * Checks if this function has yet-to-be-generated child functions 737 * 738 * @return true if there are lazy child functions 739 */ 740 public boolean hasLazyChildren() { 741 return getFlag(HAS_LAZY_CHILDREN); 742 } 743 744 /** 745 * Get the parameters to this function 746 * @return a list of IdentNodes which represent the function parameters, in order 747 */ 748 public List<IdentNode> getParameters() { 749 return Collections.unmodifiableList(parameters); 750 } 751 752 /** 753 * Reset the compile unit used to compile this function 754 * @see Compiler 755 * @param lc lexical context 756 * @param parameters the compile unit 757 * @return function node or a new one if state was changed 758 */ 759 public FunctionNode setParameters(final LexicalContext lc, final List<IdentNode> parameters) { 760 if (this.parameters == parameters) { 761 return this; 762 } 763 return Node.replaceInLexicalContext(lc, this, new FunctionNode(this, lastToken, flags, name, returnType, compileUnit, compilationState, body, parameters, snapshot, hints)); 764 } 765 766 /** 767 * Check if this function is created as a function declaration (as opposed to function expression) 768 * @return true if function is declared. 769 */ 770 public boolean isDeclared() { 771 return getFlag(IS_DECLARED); 772 } 773 774 /** 775 * Check if this function is anonymous 776 * @return true if function is anonymous 777 */ 778 public boolean isAnonymous() { 779 return getFlag(IS_ANONYMOUS); 780 } 781 782 /** 783 * Does this function need a self symbol - this is needed only for self 784 * referring functions 785 * @return true if function needs a symbol for self 786 */ 787 public boolean needsSelfSymbol() { 788 return body.getFlag(Block.NEEDS_SELF_SYMBOL); 789 } 790 791 @Override 792 public Type getType() { 793 return FUNCTION_TYPE; 794 } 795 796 /** 797 * Get the return type for this function. Return types can be specialized 798 * if the compiler knows them, but parameters cannot, as they need to go through 799 * appropriate object conversion 800 * 801 * @return the return type 802 */ 803 public Type getReturnType() { 804 return returnType; 805 } 806 807 /** 808 * Set the function return type 809 * @param lc lexical context 810 * @param returnType new return type 811 * @return function node or a new one if state was changed 812 */ 813 public FunctionNode setReturnType(final LexicalContext lc, final Type returnType) { 814 //we never bother with object types narrower than objects, that will lead to byte code verification errors 815 //as for instance even if we know we are returning a string from a method, the code generator will always 816 //treat it as an object, at least for now 817 if (this.returnType == returnType) { 818 return this; 819 } 820 final Type type = Type.widest(this.returnType, returnType.isObject() ? Type.OBJECT : returnType); 821 return Node.replaceInLexicalContext( 822 lc, 823 this, 824 new FunctionNode( 825 this, 826 lastToken, 827 flags, 828 name, 829 type, 830 compileUnit, 831 compilationState, 832 body.setReturnType(type), 833 parameters, 834 snapshot, 835 hints)); 836 } 837 838 /** 839 * Check if the function is generated in strict mode 840 * @return true if strict mode enabled for function 841 */ 842 public boolean isStrict() { 843 return getFlag(IS_STRICT); 844 } 845 846 /** 847 * Get the compile unit used to compile this function 848 * @see Compiler 849 * @return the compile unit 850 */ 851 public CompileUnit getCompileUnit() { 852 return compileUnit; 853 } 854 855 /** 856 * Reset the compile unit used to compile this function 857 * @see Compiler 858 * @param lc lexical context 859 * @param compileUnit the compile unit 860 * @return function node or a new one if state was changed 861 */ 862 public FunctionNode setCompileUnit(final LexicalContext lc, final CompileUnit compileUnit) { 863 if (this.compileUnit == compileUnit) { 864 return this; 865 } 866 return Node.replaceInLexicalContext(lc, this, new FunctionNode(this, lastToken, flags, name, returnType, compileUnit, compilationState, body, parameters, snapshot, hints)); 867 } 868 869 /** 870 * Create a temporary variable to the current frame. 871 * 872 * @param block that needs the temporary 873 * @param type Strong type of symbol. 874 * @param node Primary node to use symbol. 875 * 876 * @return Symbol used. 877 */ 878 879 /** 880 * Get the symbol for a compiler constant, or null if not available (yet) 881 * @param cc compiler constant 882 * @return symbol for compiler constant, or null if not defined yet (for example in Lower) 883 */ 884 public Symbol compilerConstant(final CompilerConstants cc) { 885 return body.getExistingSymbol(cc.symbolName()); 886 } 887 }