Returns <code>true</code> if the linked receiver may be passed as an argument. Basically everything could
be passed as an argument except the linked receiver is null, a proxy or a reference to <code>super</code>.
420389
protected boolean isValidFeatureCallArgument(XExpression expression, JvmIdentifiableElement linkedReceiver, IFeatureScopeSession session) {
		if (linkedReceiver instanceof JvmType) {
			IEObjectDescription knownSuperType = session.getLocalElement(SUPER);
			if (knownSuperType != null && linkedReceiver == knownSuperType.getEObjectOrProxy()) {
				return false;
			}
		}
		return !(expression instanceof XAbstractFeatureCall) || linkedReceiver != null && !linkedReceiver.eIsProxy();
	}
698199
public static boolean isAssignableFrom(Type a, Type b) {
    if (a instanceof Class<?>) {
      Class<?> classA = (Class<?>) a;
      if (b instanceof Class<?>) {
        return classA.isAssignableFrom((Class<?>) b);
      } else if (b instanceof GenericArrayType) {
        return classA.isArray() && isAssignableFrom(
            classA.getComponentType(), ((GenericArrayType) b).getGenericComponentType());
      } else if (b instanceof ParameterizedType) {
        return classA.isAssignableFrom((Class<?>) ((ParameterizedType) b).getRawType());
      } else if (b instanceof TypeVariable<?>) {
        TypeVariable<?> typeVariableB = (TypeVariable<?>) b;
        for (Type upperBound : typeVariableB.getBounds()) {
          if (!isAssignableFrom(a, upperBound)) {
            return false;
          }
        }
        return true;
      } else if (b instanceof WildcardType) {
        WildcardType wildcardTypeB = (WildcardType) b;
        for (Type upperBound : wildcardTypeB.getUpperBounds()) {
          if (!isAssignableFrom(a, upperBound)) {
            return false;
          }
        }
        return true;
      }
    } else if (a instanceof GenericArrayType) {
      if (b instanceof GenericArrayType) {
        return isAssignableFrom(
            ((GenericArrayType) a).getGenericComponentType(),
            ((GenericArrayType) b).getGenericComponentType());
      }
    } else if (a instanceof ParameterizedType) {
      ParameterizedType parameterizedTypeA = (ParameterizedType) a;
      if (b instanceof Class<?>) {
        return isAssignableFrom(parameterizedTypeA.getRawType(), b);
      } else if (b instanceof ParameterizedType) {
        ParameterizedType parameterizedTypeB = (ParameterizedType) b;
        Type[] actualTypeArgumentsA = parameterizedTypeA.getActualTypeArguments();
        Type[] actualTypeArgumentsB = parameterizedTypeB.getActualTypeArguments();
        if (actualTypeArgumentsA.length != actualTypeArgumentsB.length) {
          return false;
        }
        for (int i = 0; i < actualTypeArgumentsA.length; i++) {
          if (!isInstance(actualTypeArgumentsA[i], actualTypeArgumentsB[i])) {
            return false;
          }
        }
        return isAssignableFrom(
            parameterizedTypeA.getRawType(),
            parameterizedTypeB.getRawType());
      }
    } else if (a instanceof TypeVariable<?>) {
      for (Type bound : ((TypeVariable<?>) a).getBounds()) {
        if (!isAssignableFrom(bound, b)) {
          return false;
        }
      }
      return true;
    } else if (a instanceof WildcardType) {
      WildcardType wildcardType = (WildcardType) a;
      Type[] lowerBounds = wildcardType.getLowerBounds();
      for (Type lowerBound : lowerBounds) {
        if (!isAssignableFrom(lowerBound, b)) {
          return false;
        }
      }
      return lowerBounds.length != 0;
    }
    return false;
  }
249243
public static boolean isSameMetaClass(MetaClass mc, Object receiver) {
        //TODO: remove this method if possible by switchpoint usage
        return receiver instanceof GroovyObject && mc==((GroovyObject)receiver).getMetaClass(); 
    }
1078486
protected boolean isReassignmentOperator(XBinaryOperation operator) {
		if (operator.isReassignFirstArgument()) {
			return true;
		}
		final QualifiedName operatorName = this.operatorMapping.getOperator(
				QualifiedName.create(operator.getFeature().getSimpleName()));
		final QualifiedName compboundOperatorName = this.operatorMapping.getSimpleOperator(operatorName);
		return compboundOperatorName != null;
	}
946883
public boolean isReceiveExclusive()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "isReceiveExclusive");
    
    boolean isReceiveExclusive = definition.isReceiveExclusive();
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "isReceiveExclusive", Boolean.valueOf(isReceiveExclusive));
     
    return isReceiveExclusive; 
  }
665960
private boolean canBeConvertedToJUnit4(VisitorState state, List<Type> argumentTypes) {
    // Delta argument is used.
    if (argumentTypes.size() > 2) {
      return true;
    }
    Type firstType = argumentTypes.get(0);
    Type secondType = argumentTypes.get(1);
    // Neither argument is floating-point.
    if (!isFloatingPoint(state, firstType) && !isFloatingPoint(state, secondType)) {
      return true;
    }
    // One argument is not numeric.
    if (!isNumeric(state, firstType) || !isNumeric(state, secondType)) {
      return true;
    }
    // Neither argument is primitive.
    if (!firstType.isPrimitive() && !secondType.isPrimitive()) {
      return true;
    }
    return false;
  }
49592
protected boolean isGetClassOnTypeLiteral() {
		JvmIdentifiableElement feature = getFeature();
		if (isGetClass(feature)) {
			XExpression receiver = getSyntacticReceiver();
			if (receiver instanceof XAbstractFeatureCall) {
				IFeatureLinkingCandidate linkingCandidate = getState().getResolvedTypes().getLinkingCandidate((XAbstractFeatureCall) receiver);
				if (linkingCandidate != null && linkingCandidate.isTypeLiteral()) {
					return true;
				}
			}
		}
		return false;
	}
342568
private boolean isCandidate(String name, ArrayList<Node> refs) {
    if (!OptimizeCalls.mayBeOptimizableName(compiler, name)) {
      return false;
    }

    boolean seenCandidateDefiniton = false;
    boolean seenCandidateUse = false;
    for (Node n : refs) {
      // TODO(johnlenz): Determine what to do about ".constructor" references.
      // Currently classes that are super classes or have superclasses aren't optimized
      //
      // if (parent.isCall() && n != parent.getFirstChild() && isClassDefiningCall(parent)) {
      //   continue;
      // } else

      if (ReferenceMap.isCallOrNewTarget(n)) {
        // TODO(johnlenz): filter .apply when we support it
        seenCandidateUse = true;
      } else if (isCandidateDefinition(n)) {
        seenCandidateDefiniton = true;
      } else {
        // If this isn't an non-aliasing reference (typeof, instanceof, etc)
        // then there is nothing that can be done.
        if (!OptimizeCalls.isAllowedReference(n)) {
          // TODO(johnlenz): allow extends clauses.
          return false;
        }
      }
    }

    return seenCandidateDefiniton && seenCandidateUse;
  }
545318
private boolean isStreamBlocked()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        {
            SibTr.entry(this, tc, "isStreamBlocked");
            SibTr.exit(tc, "isStreamBlocked", new Object[] { Boolean.valueOf(isStreamBlocked),
                                                            Long.valueOf(linkBlockingTick) });
        }
        return this.isStreamBlocked;

    }
603512
public static boolean isLinkCellule (byte[] b) {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "isLinkCellule", new Object[]{ b });

    boolean rc = false;

    if (b.length > 0) {
      rc = (b[0] == LINKCELLULE);
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "isLinkCellule", Boolean.valueOf(rc));
    return rc;
  }
915850
private boolean isGoodRefToAdd(@Nullable StaticRef ref) {
    return ref != null
        && ref.getNode() != null
        && ref.getNode().getStaticSourceFile() != null
        && !Compiler.SYNTHETIC_EXTERNS.equals(ref.getNode().getStaticSourceFile().getName());
  }
405100
private boolean hasVariantPostProcessor(JoinableResourceBundle bundle) {

		boolean hasVariantPostProcessor = false;
		ResourceBundlePostProcessor bundlePostProcessor = bundle.getBundlePostProcessor();
		if (bundlePostProcessor != null
				&& ((AbstractChainedResourceBundlePostProcessor) bundlePostProcessor).isVariantPostProcessor()) {
			hasVariantPostProcessor = true;
		} else {
			bundlePostProcessor = bundle.getUnitaryPostProcessor();
			if (bundlePostProcessor != null
					&& ((AbstractChainedResourceBundlePostProcessor) bundlePostProcessor).isVariantPostProcessor()) {
				hasVariantPostProcessor = true;
			}
		}

		return hasVariantPostProcessor;
	}
528088
protected boolean tryBridgeMethod(MethodNode target, Expression receiver, boolean implicitThis, TupleExpression args) {
        ClassNode lookupClassNode;
        if (target.isProtected()) {
            lookupClassNode = controller.getClassNode();
            if (controller.isInClosure()) {
                lookupClassNode = lookupClassNode.getOuterClass();
            }
        } else {
            lookupClassNode = target.getDeclaringClass().redirect();
        }
        Map<MethodNode, MethodNode> bridges = lookupClassNode.getNodeMetaData(PRIVATE_BRIDGE_METHODS);
        MethodNode bridge = bridges==null?null:bridges.get(target);
        if (bridge != null) {
            Expression fixedReceiver = receiver;
            ClassNode classNode = implicitThis?controller.getClassNode():null;
            ClassNode declaringClass = bridge.getDeclaringClass();
            if (implicitThis && !controller.isInClosure()
                    && !classNode.isDerivedFrom(declaringClass)
                    && !classNode.implementsInterface(declaringClass)
                    && classNode instanceof InnerClassNode) {
                fixedReceiver = new PropertyExpression(new ClassExpression(classNode.getOuterClass()), "this");
            }
            ArgumentListExpression newArgs = new ArgumentListExpression(target.isStatic()?new ConstantExpression(null):fixedReceiver);
            for (Expression expression : args.getExpressions()) {
                newArgs.addExpression(expression);
            }
            return writeDirectMethodCall(bridge, implicitThis, fixedReceiver, newArgs);
        }
        return false;
    }
345622
public boolean isLink()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
    {
      SibTr.entry(tc, "isLink");
      SibTr.exit(tc, "isLink", Boolean.valueOf(true));
    }
    return true;
  }
834928
public Boolean visit(final CompilationUnit n, final Object arg) {
        final Boolean result = super.visit(n, arg);
        return result != null && result;
    }
1077737
public boolean isApplicable( VarValueDef value)
    {
    return
      value.isNA()
      ? isOptional()
      : getValue( value.getName()) != null;
    }
1303255
function _super(methodName, args) {
	// Keep track of how far up the prototype chain we have traversed,
	// in order to handle nested calls to _super.
	if (this._superCallObjects === undefined) { this._superCallObjects = {}; }
	var oldSuperCallback = this._superCallObjects[methodName],
		currentObject = oldSuperCallback || this,
		parentObject  = findSuper(methodName, currentObject),
		result;
	this._superCallObjects[methodName] = parentObject;

	try {
		result = parentObject[methodName].apply(this, args || []);
	} finally {
		if (oldSuperCallback) {
			this._superCallObjects[methodName] = oldSuperCallback;
		} else {
			delete this._superCallObjects[methodName];
		}
	}
	return result;
}