Return whether or not the given method is concrete.

@param xmethod
the method
@return true if the method is concrete, false otherwise
433820
@Deprecated
    public static boolean isConcrete(XMethod xmethod) {
        int accessFlags = xmethod.getAccessFlags();
        return (accessFlags & Const.ACC_ABSTRACT) == 0 && (accessFlags & Const.ACC_NATIVE) == 0;
    }
620179
private static function methodCannotBeProxied(ReflectionMethod $method) : bool
    {
        return $method->isConstructor() || $method->isFinal() || $method->isStatic();
    }
1164463
public static boolean isConcrete( Class<?> clazz ) {
        return !Modifier.isAbstract(clazz.getModifiers()) &&
                !Modifier.isInterface(clazz.getModifiers());
    }
34368
private static boolean isAsyncMethod(Method method) {
        Class<?>[] parameterTypes = method.getParameterTypes();
        for (Class<?> c : parameterTypes)
        {
            if (c.isAssignableFrom(javax.ws.rs.container.AsyncResponse.class))
                return true;
        }
        return false;
    }
700109
@Nullable
    public static XMethod getXMethod(final XClass xClass, final String methodName, final String methodSig) {
        if (xClass == null) {
            return null;
        }

        XMethod xMethod = xClass.findMethod(methodName, methodSig, false);
        if (xMethod == null) {
            ClassDescriptor descriptor = xClass.getSuperclassDescriptor();
            if (descriptor != null) {
                final XClass superClass = getXClass(descriptor);
                xMethod = getXMethod(superClass, methodName, methodSig);
            }
        }
        return xMethod;
    }
1165941
private static boolean isDesignerMethod(Method method) {
        Class<?>[] parameterTypes = method.getParameterTypes();

        for (Class<?> parameterType : parameterTypes) {
            if (parameterType.isAssignableFrom(TestDesigner.class)) {
                return true;
            }
        }

        return false;
    }
207584
private static boolean isGetterMethod(Method method) {
		return !Modifier.isStatic(method.getModifiers())
			&& (method.getName().startsWith("get") || method.getName().startsWith("is"))
			&& method.getParameterTypes().length == 0;
	}
923363
private boolean classifyMethods(
      Iterable<ExecutableElement> methods, boolean autoValueHasToBuilder) {
    int startErrorCount = errorReporter.errorCount();
    for (ExecutableElement method : methods) {
      classifyMethod(method);
    }
    if (errorReporter.errorCount() > startErrorCount) {
      return false;
    }
    Multimap<String, ExecutableElement> propertyNameToSetter;
    if (propertyNameToPrefixedSetters.isEmpty()) {
      propertyNameToSetter = propertyNameToUnprefixedSetters;
      this.settersPrefixed = false;
    } else if (propertyNameToUnprefixedSetters.isEmpty()) {
      propertyNameToSetter = propertyNameToPrefixedSetters;
      this.settersPrefixed = true;
    } else {
      errorReporter.reportError(
          "If any setter methods use the setFoo convention then all must",
          propertyNameToUnprefixedSetters.values().iterator().next());
      return false;
    }
    getterToPropertyName.forEach(
        (getter, property) -> {
          TypeMirror propertyType = getterToPropertyType.get(getter);
          boolean hasSetter = propertyNameToSetter.containsKey(property);
          PropertyBuilder propertyBuilder = propertyNameToPropertyBuilder.get(property);
          boolean hasBuilder = propertyBuilder != null;
          if (hasBuilder) {
            // If property bar of type Bar has a barBuilder() that returns BarBuilder, then it must
            // be possible to make a BarBuilder from a Bar if either (1) the @AutoValue class has a
            // toBuilder() or (2) there is also a setBar(Bar). Making BarBuilder from Bar is
            // possible if Bar either has a toBuilder() method or is a Guava immutable collection
            // (in which case we can use addAll or putAll).
            boolean canMakeBarBuilder =
                (propertyBuilder.getBuiltToBuilder() != null
                    || propertyBuilder.getCopyAll() != null);
            boolean needToMakeBarBuilder = (autoValueHasToBuilder || hasSetter);
            if (needToMakeBarBuilder && !canMakeBarBuilder) {
              String error =
                  String.format(
                      "Property builder method returns %1$s but there is no way to make that type"
                          + " from %2$s: %2$s does not have a non-static toBuilder() method that"
                          + " returns %1$s",
                      propertyBuilder.getBuilderTypeMirror(), propertyType);
              errorReporter.reportError(error, propertyBuilder.getPropertyBuilderMethod());
            }
          } else if (!hasSetter) {
            // We have neither barBuilder() nor setBar(Bar), so we should complain.
            String setterName = settersPrefixed ? prefixWithSet(property) : property;
            String error =
                String.format(
                    "Expected a method with this signature: %s%s %s(%s), or a %sBuilder() method",
                    builderType, typeParamsString(), setterName, propertyType, property);
            errorReporter.reportError(error, builderType);
          }
        });
    return errorReporter.errorCount() == startErrorCount;
  }
219577
public static XMethod createXMethod(JavaClass javaClass, Method method) {
        if (method == null) {
            throw new NullPointerException("method must not be null");
        }
        XMethod xmethod = createXMethod(javaClass.getClassName(), method);
        assert xmethod.isResolved();
        return xmethod;
    }
1373661
public static boolean isToStringMethod(Method method) {
        return (method != null && method.getName().equals("readString") && method.getParameterTypes().length == 0);
    }
971197
public static boolean isEqualsMethod(Method method) {
		if (method == null || false == method.getName().equals("equals")) {
			return false;
		}
		final Class<?>[] paramTypes = method.getParameterTypes();
		return (1 == paramTypes.length && paramTypes[0] == Object.class);
	}
634266
private boolean isIsGetter(AptMethod method) {
        String methodName = method.getName();

        if (methodName.length() < 3)
            return false;

        if (!methodName.startsWith("is"))
            return false;

        if (method.getArgList().length() > 0)
            return false;

        if (!"boolean".equals(method.getReturnType()))
            return false;

        return true;
    }
51699
@Deprecated
    public static @CheckForNull
    JavaClassAndMethod findConcreteMethod(JavaClass javaClass, String methodName, String methodSig) {

        if (DEBUG_METHOD_LOOKUP) {
            System.out.println("Check " + javaClass.getClassName());
        }
        Method[] methodList = javaClass.getMethods();
        for (Method method : methodList) {
            if (method.getName().equals(methodName) && method.getSignature().equals(methodSig)
                    && accessFlagsAreConcrete(method.getAccessFlags())) {
                JavaClassAndMethod m = new JavaClassAndMethod(javaClass, method);

                return m;

            }
        }
        if (DEBUG_METHOD_LOOKUP) {
            System.out.println("\t==> NOT FOUND");
        }
        return null;
    }
572972
private static boolean hasMethod(JavaClass c, Method candidateMethod) {
		String name = candidateMethod.getName();
		String sig = candidateMethod.getSignature();

		for (Method method : c.getMethods()) {
			if (!method.isStatic() && method.getName().equals(name) && method.getSignature().equals(sig)) {
				return true;
			}
		}

		return false;
	}
1193868
function isStaticMethodCall(node) {
  if (node.type === 'CallExpression') {
    if (node.callee.type === 'MemberExpression' &&
        isConstructor(node.callee.object) &&
        node.callee.property.type === 'Identifier') {
      return true;
    }
  }
  return false;
}
605800
public static String convertMethodSignature(XMethod xmethod) {
        @DottedClassName
        String className = xmethod.getClassName();
        assert className.indexOf('/') == -1;
        return convertMethodSignature(className, xmethod.getName(), xmethod.getSignature());
    }
44941
public void setMethodHash(XMethod method, byte[] methodHash) {
        methodHashMap.put(method, new MethodHash(method.getName(), method.getSignature(), method.isStatic(), methodHash));
    }