Returns {@code true} is the return type is {@link Void} or represents the pseudo-type to the keyword {@code void}.
E.g:  {@code void foo()} or {@code Void bar()}
763775
public boolean isVoid() {
        final MockCreationSettings mockSettings = MockUtil.getMockHandler(invocation.getMock())
            .getMockSettings();
        Class<?> returnType = GenericMetadataSupport.inferFrom(mockSettings.getTypeToMock())
            .resolveGenericReturnType(this.method)
            .rawType();
        return returnType == Void.TYPE || returnType == Void.class;
    }
753014
private static boolean isPrototypeMethodDefinition(Node node) {
    Node parent = node.getParent();
    Node grandparent = node.getGrandparent();
    if (parent == null || grandparent == null) {
      return false;
    }

    switch (node.getToken()) {
      case MEMBER_FUNCTION_DEF:
        if (NodeUtil.isEs6ConstructorMemberFunctionDef(node)) {
          return false; // Constructors aren't methods.
        }

        return true;

      case GETPROP:
        {
          // Case: `Foo.prototype.bar = function() { };
          if (parent.getFirstChild() != node) {
            return false;
          }

          if (!NodeUtil.isExprAssign(grandparent)) {
            return false;
          }

          Node functionNode = parent.getLastChild();
          if ((functionNode == null) || !functionNode.isFunction()) {
            return false;
          }

          Node nameNode = node.getFirstChild();
          return nameNode.isGetProp() && nameNode.getLastChild().getString().equals("prototype");
        }

      case STRING_KEY:
        {
          // Case: `Foo.prototype = {
          //          bar: function() { },
          //        }`
          checkArgument(parent.isObjectLit(), parent);

          if (!grandparent.isAssign()) {
            return false;
          }

          if (grandparent.getLastChild() != parent) {
            return false;
          }

          Node greatgrandparent = grandparent.getParent();
          if (greatgrandparent == null || !greatgrandparent.isExprResult()) {
            return false;
          }

          Node functionNode = node.getFirstChild();
          if ((functionNode == null) || !functionNode.isFunction()) {
            return false;
          }

          Node target = grandparent.getFirstChild();
          return target.isGetProp() && target.getLastChild().getString().equals("prototype");
        }

      default:
        return false;
    }
  }
686812
public Class<?> getType()
    {
        if ( this == Primitive.VOID )
            return Void.TYPE;

        // NULL return null as type... we currently use null type to indicate
        // loose typing throughout bsh.
        if ( this == Primitive.NULL )
            return null;

        return unboxType( value.getClass() );
    }
852274
public static boolean isPrimitive(Class<?> javaType)
   {
      return javaType.isPrimitive() || (javaType.isArray() && isPrimitive(javaType.getComponentType()));
   }
1118374
public static boolean isJavaBasicType(@Nullable Class<?> type) {
        if (type == null) {
            return false;
        }
        final String name = type.getName();
        return isJavaBasicType(name);
    }
560410
final public Boolean checkPositionType(String type) {
    if (tokenPosition == null) {
      return false;
    } else {
      return tokenPosition.checkType(type);
    }
  }
393939
public boolean isLvalue() {
    Node parent = getParent();
    Token parentType = parent.getToken();
    switch (parentType) {
      case VAR:
      case LET:
      case CONST:
        return (nameNode.hasChildren() || isLhsOfEnhancedForExpression(nameNode));
      case DEFAULT_VALUE:
        return parent.getFirstChild() == nameNode;
      case INC:
      case DEC:
      case CATCH:
      case REST:
      case PARAM_LIST:
        return true;
      case FOR:
      case FOR_IN:
      case FOR_OF:
      case FOR_AWAIT_OF:
        return NodeUtil.isEnhancedFor(parent) && parent.getFirstChild() == nameNode;
      case ARRAY_PATTERN:
      case STRING_KEY:
      case COMPUTED_PROP:
        return NodeUtil.isLhsByDestructuring(nameNode);
      default:
        return (NodeUtil.isAssignmentOp(parent) && parent.getFirstChild() == nameNode);
    }
  }
383624
public final static boolean isJavaKeyword(String s)
   {
      if (s == null || s.length() == 0)
      {
         return false;
      }

      for (int i = 0; i < keywords.length; i++)
      {
         if (keywords[i].equals(s))
         {
            return true;
         }
      }

      return false;
   }
1054276
private static boolean isPrimitive(Class<? extends Object> c) {
		return (null == c) || (Class.class == c) || (String.class == c) || c.isPrimitive() || (Integer.class == c) || (Long.class == c)
				|| (Short.class == c) || (Byte.class == c) || (Character.class == c) || (Float.class == c) || (Double.class == c)
				|| (Void.class == c) || (Boolean.class == c);
	}
1139489
public final JavaParser.type_return type() throws RecognitionException {
		JavaParser.type_return retval = new JavaParser.type_return();
		retval.start = input.LT(1);
		int type_StartIndex = input.index();

		try {
			if ( state.backtracking>0 && alreadyParsedRule(input, 50) ) { return retval; }

			// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:532:5: ( Identifier ( typeArguments )? ( '.' Identifier ( typeArguments )? )* ( '[' ']' )* | primitiveType ( '[' ']' )* )
			int alt72=2;
			int LA72_0 = input.LA(1);
			if ( (LA72_0==Identifier) ) {
				alt72=1;
			}
			else if ( (LA72_0==65||LA72_0==67||LA72_0==71||LA72_0==77||LA72_0==85||LA72_0==92||LA72_0==94||LA72_0==105) ) {
				alt72=2;
			}

			else {
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae =
					new NoViableAltException("", 72, 0, input);
				throw nvae;
			}

			switch (alt72) {
				case 1 :
					// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:532:7: Identifier ( typeArguments )? ( '.' Identifier ( typeArguments )? )* ( '[' ']' )*
					{
					match(input,Identifier,FOLLOW_Identifier_in_type1776); if (state.failed) return retval;
					// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:532:18: ( typeArguments )?
					int alt67=2;
					int LA67_0 = input.LA(1);
					if ( (LA67_0==53) ) {
						int LA67_1 = input.LA(2);
						if ( (LA67_1==Identifier||LA67_1==57||LA67_1==65||LA67_1==67||LA67_1==71||LA67_1==77||LA67_1==85||LA67_1==92||LA67_1==94||LA67_1==105) ) {
							alt67=1;
						}
					}
					switch (alt67) {
						case 1 :
							// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:532:19: typeArguments
							{
							pushFollow(FOLLOW_typeArguments_in_type1779);
							typeArguments();
							state._fsp--;
							if (state.failed) return retval;
							}
							break;

					}

					// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:532:35: ( '.' Identifier ( typeArguments )? )*
					loop69:
					while (true) {
						int alt69=2;
						int LA69_0 = input.LA(1);
						if ( (LA69_0==47) ) {
							alt69=1;
						}

						switch (alt69) {
						case 1 :
							// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:532:36: '.' Identifier ( typeArguments )?
							{
							match(input,47,FOLLOW_47_in_type1784); if (state.failed) return retval;
							match(input,Identifier,FOLLOW_Identifier_in_type1786); if (state.failed) return retval;
							// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:532:51: ( typeArguments )?
							int alt68=2;
							int LA68_0 = input.LA(1);
							if ( (LA68_0==53) ) {
								int LA68_1 = input.LA(2);
								if ( (LA68_1==Identifier||LA68_1==57||LA68_1==65||LA68_1==67||LA68_1==71||LA68_1==77||LA68_1==85||LA68_1==92||LA68_1==94||LA68_1==105) ) {
									alt68=1;
								}
							}
							switch (alt68) {
								case 1 :
									// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:532:52: typeArguments
									{
									pushFollow(FOLLOW_typeArguments_in_type1789);
									typeArguments();
									state._fsp--;
									if (state.failed) return retval;
									}
									break;

							}

							}
							break;

						default :
							break loop69;
						}
					}

					// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:532:71: ( '[' ']' )*
					loop70:
					while (true) {
						int alt70=2;
						int LA70_0 = input.LA(1);
						if ( (LA70_0==59) ) {
							alt70=1;
						}

						switch (alt70) {
						case 1 :
							// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:532:72: '[' ']'
							{
							match(input,59,FOLLOW_59_in_type1797); if (state.failed) return retval;
							match(input,60,FOLLOW_60_in_type1799); if (state.failed) return retval;
							}
							break;

						default :
							break loop70;
						}
					}

					}
					break;
				case 2 :
					// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:533:7: primitiveType ( '[' ']' )*
					{
					pushFollow(FOLLOW_primitiveType_in_type1809);
					primitiveType();
					state._fsp--;
					if (state.failed) return retval;
					// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:533:21: ( '[' ']' )*
					loop71:
					while (true) {
						int alt71=2;
						int LA71_0 = input.LA(1);
						if ( (LA71_0==59) ) {
							alt71=1;
						}

						switch (alt71) {
						case 1 :
							// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:533:22: '[' ']'
							{
							match(input,59,FOLLOW_59_in_type1812); if (state.failed) return retval;
							match(input,60,FOLLOW_60_in_type1814); if (state.failed) return retval;
							}
							break;

						default :
							break loop71;
						}
					}

					}
					break;

			}
			retval.stop = input.LT(-1);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
			if ( state.backtracking>0 ) { memoize(input, 50, type_StartIndex); }

		}
		return retval;
	}
1310228
public final void mVOID() throws RecognitionException {
        try {
            int _type = VOID;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/dyuproject/protostuff/parser/ProtoLexer.g:223:5: ( 'void' )
            // com/dyuproject/protostuff/parser/ProtoLexer.g:223:9: 'void'
            {
            match("void"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
41978
private static boolean isCallTo(Node n, Node targetMethod) {
    if (!n.isCall()) {
      return false;
    }
    Node method = n.getFirstChild();
    return method.isGetProp() && method.matchesQualifiedName(targetMethod);
  }
1319595
public boolean check() {
        if (!method.getReturnType().equals(Void.TYPE)) {
            WebSocketRouter.getLogger().error("The method {} annotated with a web socket callback is not well-formed. " +
                            "These methods receive only parameter annotated with @Parameter and do not return anything",
                    method.getName()
            );
            return false;
        }

        List<ActionParameter> localArguments = buildArguments(method);
        if (localArguments == null) {
            return false;
        } else {
            this.arguments = localArguments;
            return true;
        }
    }
817518
private boolean isSearchingForVariantInPostProcessNeeded() {
		boolean needToSearch = false;

		ResourceBundlePostProcessor[] postprocessors = new ResourceBundlePostProcessor[] { postProcessor,
				unitaryCompositePostProcessor, compositePostProcessor, unitaryCompositePostProcessor };
		for (ResourceBundlePostProcessor resourceBundlePostProcessor : postprocessors) {
			if (resourceBundlePostProcessor != null
					&& ((AbstractChainedResourceBundlePostProcessor) resourceBundlePostProcessor)
							.isVariantPostProcessor()) {
				needToSearch = true;
				break;
			}
		}

		return needToSearch;
	}
691599
public static boolean isPrimitive(String type) {
        boolean isPrimitive = false;
        if ( "byte".equals( type ) || "char".equals( type ) || "double".equals( type ) || "float".equals( type ) || "int".equals( type ) || "long".equals( type ) || "short".equals( type ) || "boolean".equals( type ) || "void".equals( type ) ) {
            isPrimitive = true;
        }
        return isPrimitive;
    }
221242
public boolean isSubtypeOf(JvmType type) {
		if (type == null) {
			throw new IllegalArgumentException("type may not be null");
		}
		// TODO interfaces don't inherit from non-interfaces, primitives, arrays, object
		// A final type does not have any subtypes
		// check for type == this.type
		LightweightTypeReference other = owner.toPlainTypeReference(type);
		boolean result = other.isAssignableFrom(this);
		return result;
	}
799121
@Override
    public boolean isReturnTypeReferenceType() {
        SignatureParser parser = new SignatureParser(getSignature());
        String returnTypeSig = parser.getReturnTypeSignature();
        return SignatureParser.isReferenceType(returnTypeSig);
    }