static method because the builder pattern version was showing up during profiling
774454
public static EntityKey fromData(
			EntityKeyMetadata entityKeyMetadata,
			GridType identifierGridType,
			final Serializable id,
			SharedSessionContractImplementor session) {
		Object[] values = LogicalPhysicalConverterHelper.getColumnsValuesFromObjectValue(
				id,
				identifierGridType,
				entityKeyMetadata.getColumnNames(),
				session
		);
		return new EntityKey( entityKeyMetadata, values );
	}
624023
static Pattern createIncludedFilesPattern() {
		String messagesFilesRegex = LocaleUtils.createResourceFilesRegex(Constant.MESSAGES_PREFIX, Constant.MESSAGES_EXTENSION);
		String vulnerabilitiesFilesRegex = LocaleUtils.createResourceFilesRegex(
				Constant.VULNERABILITIES_PREFIX,
				Constant.VULNERABILITIES_EXTENSION);
		StringBuilder strBuilder = new StringBuilder(messagesFilesRegex.length() + vulnerabilitiesFilesRegex.length() + 1);
		strBuilder.append(messagesFilesRegex).append('|').append(vulnerabilitiesFilesRegex);
		return Pattern.compile(strBuilder.toString());
	}
1127206
@Nonnull
	public static <T1, T2> LBiObjDblPredicate<T1, T2> biObjDblPredicateFrom(Consumer<LBiObjDblPredicateBuilder<T1, T2>> buildingFunction) {
		LBiObjDblPredicateBuilder builder = new LBiObjDblPredicateBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
1352427
@Nonnull
	public static <T1, T2, R> LBiObjLongFunction<T1, T2, R> biObjLongFunctionFrom(Consumer<LBiObjLongFunctionBuilder<T1, T2, R>> buildingFunction) {
		LBiObjLongFunctionBuilder builder = new LBiObjLongFunctionBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
1250535
private Artifact<?> emitLandingPageCacheManifest(LinkerContext context, TreeLogger logger,
      ArtifactSet artifacts, String[] staticFiles) throws UnableToCompleteException {
    // Create a string of cacheable resources
    StringBuilder publicSourcesSb = new StringBuilder();
    StringBuilder publicStaticSourcesSb = new StringBuilder();

    // Iterate over all emitted artifacts, and collect all cacheable artifacts
    for (@SuppressWarnings("rawtypes")
    Artifact artifact : artifacts) {
      if (artifact instanceof EmittedArtifact) {
        EmittedArtifact ea = (EmittedArtifact) artifact;
        String path = "/" + context.getModuleFunctionName() + "/" + ea.getPartialPath();

        if (accept(path)) {
          publicSourcesSb.append(path + "\n");
        }
      }
    }

    // Iterate over all static files
    if (staticFiles != null) {
      for (String staticFile : staticFiles) {
        if (accept(staticFile)) {
          publicStaticSourcesSb.append(staticFile + "\n");
        }
      }
    }

    // build cache list
    StringBuilder sb = new StringBuilder();
    sb.append("CACHE MANIFEST\n");
    sb.append("# Unique id #" + (new Date()).getTime() + "." + Math.random() + "\n");
    // we have to generate this unique id because the resources can change but
    // the hashed cache.html files can remain the same.
    sb.append("# Note: must change this every time for cache to invalidate\n");
    sb.append("\n");
    sb.append("CACHE:\n");
    sb.append(publicSourcesSb.toString());
    sb.append("# Static cached files\n");
    sb.append(publicStaticSourcesSb.toString());
    sb.append("\n\n");
    sb.append("# All other resources require the user to be online.\n");
    sb.append("NETWORK:\n");
    sb.append("*\n");

    logger.log(TreeLogger.DEBUG, "Make sure you have the following"
        + " attribute added to your landing page's <html> tag: <html manifest=\""
        + context.getModuleFunctionName() + "/" + MANIFEST + "\">");

    // Create the manifest as a new artifact and return it:
    return emitString(logger, sb.toString(), MANIFEST);
  }
171285
synchronized static TraceSpecification setTraceSpec(String spec) {
        // If logger is used & configured by logger properties, 
        // we're done as far as trace string processing is concerned
        if (WsLogManager.isConfiguredByLoggingProperties()) {
            return null;
        }

        // If the specified string is null, or it is equal to a string,
        // or the sensitive flag has not been toggled,
        // we've already parsed, skip it.
        if ((spec == null || spec.equals(traceString)) && Tr.activeTraceSpec.isSensitiveTraceSuppressed() == suppressSensitiveTrace) {
            return null;
        }

        traceString = spec;

        // Parse the trace specification string, this will gather
        // exceptions that occur for different elements of the string
        TraceSpecification newTs = new TraceSpecification(spec, safeLevelsIndex, suppressSensitiveTrace);
        TraceSpecificationException tex = newTs.getExceptions();

        if (tex != null) {
            do {
                tex.warning(loggingConfig.get() != null);
                tex = tex.getPreviousException();
            } while (tex != null);
        }

        Tr.setTraceSpec(newTs);

        // Return the new/updated TraceSpecification to the caller. The caller can
        // then determine whether or not all elements of the TraceSpecification 
        // were known to the system or not.
        return newTs;
    }
284524
@Nonnull
	public static <T1, T2, R> LBiObjDblFunctionBuilder<T1, T2, R> biObjDblFunction(Consumer<LBiObjDblFunction<T1, T2, R>> consumer) {
		return new LBiObjDblFunctionBuilder(consumer);
	}
236396
static void checkStatic(final Field field) throws DevFailed {
        if (Modifier.isStatic(field.getModifiers())) {
            throw DevFailedUtils.newDevFailed(DevFailedUtils.TANGO_BUILD_FAILED, field + MUST_NOT_BE_STATIC);
        }
    }
862252
@Override
    public void visitMethod(Method obj) {
        if (Values.STATIC_INITIALIZER.equals(obj.getName())) {
            return;
        }

        if (state == State.COLLECT) {
            Type[] argTypes = obj.getArgumentTypes();
            for (Type t : argTypes) {
                addType(t);
            }
            Type resultType = obj.getReturnType();
            addType(resultType);
            LocalVariableTable lvt = obj.getLocalVariableTable();
            if (lvt != null) {
                LocalVariable[] lvs = lvt.getLocalVariableTable();
                if (lvs != null) {
                    for (LocalVariable lv : lvs) {
                        if (lv != null) {
                            Type t = Type.getType(lv.getSignature());
                            addType(t);
                        }
                    }
                }
            }
        } else {
            state = State.SEEN_NOTHING;
        }
        super.visitMethod(obj);
    }
635755
private void processWatcher(MethodSpec.Builder createdMethodBuilder, ExecutableElement method) {
    Watch watch = method.getAnnotation(Watch.class);

    String exposedMethodName = exposeExistingJavaMethodToJs(method);
    String watcherTriggerMethodName = addNewMethodToProto();

    MethodSpec.Builder watcherMethodBuilder = MethodSpec
        .methodBuilder(watcherTriggerMethodName)
        .addModifiers(Modifier.PUBLIC)
        .addAnnotation(JsMethod.class)
        .returns(Object.class);

    String[] valueSplit = watch.value().split("\\.");

    String currentExpression = "";
    for (int i = 0; i < valueSplit.length - 1; i++) {
      currentExpression += valueSplit[i];
      watcherMethodBuilder.addStatement("if ($L == null) return null", currentExpression);
      currentExpression += ".";
    }

    watcherMethodBuilder.addStatement("return $L", watch.value());

    componentExposedTypeBuilder.addMethod(watcherMethodBuilder.build());

    createdMethodBuilder
        .addStatement("vue().$L(p.$L, p.$L, $T.of($L, $L))", "$watch",
            watcherTriggerMethodName, exposedMethodName, WatchOptions.class, watch.isDeep(),
            watch.isImmediate());
  }
1192699
@UnstableApi
    public <T> StaticMockitoSessionBuilder spyStatic(Class<T> clazz) {
        staticMockings.add(new StaticMocking<>(clazz, () -> Mockito.mock(clazz, withSettings()
                .defaultAnswer(CALLS_REAL_METHODS))));
        return this;
    }
1082788
private void debugVerifyCatalog(InMemoryJarfile origJarFile, Catalog origCatalog)
    {
        final VoltCompiler autoGenCompiler = new VoltCompiler(m_isXDCR);
        // Make the new compiler use the original jarfile's classloader so it can
        // pull in the class files for procedures and imports
        autoGenCompiler.m_classLoader = origJarFile.getLoader();
        List<VoltCompilerReader> autogenReaderList = new ArrayList<>(1);
        autogenReaderList.add(new VoltCompilerJarFileReader(origJarFile, AUTOGEN_DDL_FILE_NAME));
        InMemoryJarfile autoGenJarOutput = new InMemoryJarfile();
        autoGenCompiler.m_currentFilename = AUTOGEN_DDL_FILE_NAME;
        // This call is purposely replicated in retryFailedCatalogRebuildUnderDebug,
        // where it provides an opportunity to set a breakpoint on a do-over when this
        // mainline call produces a flawed catalog that fails the catalog diff.
        // Keep the two calls in synch to allow debugging under the same exact conditions.
        Catalog autoGenCatalog = autoGenCompiler.compileCatalogInternal(null, null,
                autogenReaderList, autoGenJarOutput);
        if (autoGenCatalog == null) {
            Log.info("Did not verify catalog because it could not be compiled.");
            return;
        }

        FilteredCatalogDiffEngine diffEng =
                new FilteredCatalogDiffEngine(origCatalog, autoGenCatalog, false);
        String diffCmds = diffEng.commands();
        if (diffCmds != null && !diffCmds.equals("")) {
            // This retry is disabled by default to avoid confusing the unwary developer
            // with a "pointless" replay of an apparently flawed catalog rebuild.
            // Enable it via this flag to provide a chance to set an early breakpoint
            // that is only triggered in hopeless cases.
            if (RETRY_FAILED_CATALOG_REBUILD_UNDER_DEBUG) {
                autoGenCatalog = replayFailedCatalogRebuildUnderDebug(
                        autoGenCompiler, autogenReaderList,
                        autoGenJarOutput);
            }
            // Re-run a failed diff more verbosely as a pre-crash test diagnostic.
            diffEng = new FilteredCatalogDiffEngine(origCatalog, autoGenCatalog, true);
            diffCmds = diffEng.commands();
            String crashAdvice = "Catalog Verification from Generated DDL failed! " +
                    "VoltDB dev: Consider" +
                    (RETRY_FAILED_CATALOG_REBUILD_UNDER_DEBUG ? "" :
                        " setting VoltCompiler.RETRY_FAILED_CATALOG_REBUILD_UNDER_DEBUG = true and") +
                    " setting a breakpoint in VoltCompiler.replayFailedCatalogRebuildUnderDebug" +
                    " to debug a replay of the faulty catalog rebuild roundtrip. ";
            VoltDB.crashLocalVoltDB(crashAdvice + "The offending diffcmds were: " + diffCmds);
        }
        else {
            Log.info("Catalog verification completed successfuly.");
        }
    }
999699
static synchronized Mutator mutatorFor(Class<?> type, Method method, Configuration configuration,
      String name) {
    PropertyInfoKey key = new PropertyInfoKey(type, name, configuration);
    Mutator mutator = MUTATOR_CACHE.get(key);
    if (mutator == null) {
      mutator = new MethodMutator(type, method, name);
      MUTATOR_CACHE.put(key, mutator);
    }

    return mutator;
  }
1314000
def method_missing(method, *args)
      if @builders.has_key?(method.to_s)
        target, sources, vars, *rest = args
        vars ||= {}
        unless vars.is_a?(Hash) or vars.is_a?(VarSet)
          raise "Unexpected construction variable set: #{vars.inspect}"
        end
        builder = @builders[method.to_s]
        target = expand_path(expand_varref(target))
        sources = Array(sources).map do |source|
          expand_path(expand_varref(source))
        end.flatten
        build_target = builder.create_build_target(env: self, target: target, sources: sources, vars: vars)
        add_target(build_target.to_s, builder, sources, vars, rest)
        build_target
      else
        super
      end
    end
88991
private void failOnOverlapOfClearedPropagated() {
        HashSet<String> overlap = new HashSet<String>(cleared);
        overlap.retainAll(propagated);
        if (overlap.isEmpty()) // only possible if builder is concurrently modified during build
            throw new ConcurrentModificationException();
        throw new IllegalStateException(Tr.formatMessage(tc, "CWWKC1151.context.lists.overlap", overlap));
    }
720778
private static int getBugPriority(String methodName, MethodInfo mi) {
		if (Values.STATIC_INITIALIZER.equals(methodName)) {
			return LOW_PRIORITY;
		}

		if ((mi.getNumBytes() >= highByteCountLimit) || (mi.getNumMethodCalls() >= highMethodCallLimit)) {
			return HIGH_PRIORITY;
		}

		if ((mi.getNumBytes() >= normalByteCountLimit) || (mi.getNumMethodCalls() >= normalMethodCallLimit)) {
			return NORMAL_PRIORITY;
		}

		if ((mi.getNumBytes() >= lowByteCountLimit) || (mi.getNumMethodCalls() >= lowMethodCallLimit)) {
			return LOW_PRIORITY;
		}

		return EXP_PRIORITY;
	}
255723
static Method findMatchingMethod(Map<String, List<Method>> methodsByName, com.ibm.ws.javaee.dd.ejb.Method me) {
        List<Method> methods = methodsByName.get(me.getMethodName());
        if (methods == null) {
            return null;
        }

        List<String> meParms = me.getMethodParamList();
        if (meParms == null) {
            return methods.get(0);
        }

        for (Method method : methods) {
            if (DDUtil.methodParamsMatch(meParms, method.getParameterTypes())) {
                return method;
            }
        }

        return null;
    }