Creates a new {@code GoogRequire} that requires the given symbol and aliases it to the given
name: {@code var alias = goog.require('symbol'); }
518613
public static GoogRequire createWithAlias(String symbol, String alias) {
    CodeChunkUtils.checkId(alias);
    return new AutoValue_GoogRequire(
        symbol,
        VariableDeclaration.builder(alias).setRhs(GOOG_REQUIRE.call(stringLiteral(symbol))).build(),
        /*isTypeRequire=*/ false);
  }
1359672
public void createVendor(String name, String url) {
        vendor = new GoPluginDescriptor.Vendor(name, url);
    }
1342797
public static XNElement createRequest(String function, Object... nameValue) {
        XNElement result = new XNElement(function);
        for (int i = 0; i < nameValue.length; i += 2) {
            result.set((String)nameValue[i], nameValue[i + 1]);
        }
        return result;
    }
568828
void appendGoogRequiresTo(StringBuilder sb) {
    for (GoogRequire require : googRequires.values()) {
      // TODO(lukes): we need some namespace management here... though really we need namespace
      // management with all declarations... The problem is that a require could introduce a name
      // alias that conflicts with a symbol defined elsewhere in the file.
      require.writeTo(sb);
    }
  }
188339
private Function<HttpRequestContext, String> createQuerySubstitution(final String param) {
        return new Function<HttpRequestContext, String>() {
            @Override
            public String apply(HttpRequestContext request) {
                MultivaluedMap<String, String> params = request.getQueryParameters();
                if (!params.containsKey(param)) {
                    throw new IllegalStateException("Parameter required for authentication is missing: " + param);
                }
                List<String> values = params.get(param);
                if (values.size() != 1) {
                    throw new IllegalStateException("Exactly one parameter expected for authentication: " + param);
                }
                return values.get(0);
            }
        };
    }
368166
public static GoogRequire createTypeRequire(String symbol) {
    return new AutoValue_GoogRequire(
        symbol, GOOG_REQUIRE_TYPE.call(stringLiteral(symbol)), /*isTypeRequire=*/ true);
  }
965225
private Es6SyntacticScopeCreator createScopeCreator() {
    if (validityCheck) {
      return new Es6SyntacticScopeCreator(compiler);
    } else {
      dupHandler = new RedeclarationCheckHandler();
      return new Es6SyntacticScopeCreator(compiler, dupHandler);
    }
  }
399418
function makeRequire(id, path) {
  var expr = callExpression(identifier('require'), [literal(path)]);
  return makeDeclaration(id, expr);
}
974279
public static BinaryTypeSignature createTypeSignature(String signature) {
//		if (!isSignature(signature)) {
//			throw new IllegalArgumentException(signature);
//		}
		if (signature.charAt(signature.length() - 1) != ';')
			return new BinaryTypeSignature(signature);
		return new BinaryGenericTypeSignature(signature);
	}
1020154
public GSSCredential createCredential (int usage)
	throws GSSException {
	return createCredential(null,
				GSSCredential.DEFAULT_LIFETIME,
				(Oid)null,
				usage);
    }
1336286
public GSSCredential createCredential (byte[] buff,
					   int option,
					   int lifetime,
					   Oid mech,
					   int usage)
	throws GSSException {
	checkMechanism(mech);

	if (buff == null || buff.length < 1) {
	    throw new GlobusGSSException(GSSException.FAILURE,
					 GlobusGSSException.BAD_ARGUMENT,
					 "invalidBuf");
	}

	if (lifetime == GSSCredential.INDEFINITE_LIFETIME ||
            lifetime > 0) {
            // lifetime not supported
            throw new GlobusGSSException(GSSException.FAILURE,
                                         GlobusGSSException.BAD_ARGUMENT,
                                         "badLifetime01");
	}

	InputStream input = null;

	switch (option) {
	case ExtendedGSSCredential.IMPEXP_OPAQUE:
	    input = new ByteArrayInputStream(buff);
	    break;
	case ExtendedGSSCredential.IMPEXP_MECH_SPECIFIC:
	    String s = new String(buff);
	    int pos = s.indexOf('=');
	    if (pos == -1) {
		throw new GSSException(GSSException.FAILURE);
	    }
	    String filename = s.substring(pos+1).trim();
	    try {
		input = new FileInputStream(filename);
	    } catch (IOException e) {
		throw new GlobusGSSException(GSSException.FAILURE, e);
	    }
	    break;
	default:
	    throw new GlobusGSSException(GSSException.FAILURE,
					 GlobusGSSException.BAD_ARGUMENT,
					 "unknownOption",
					 new Object[] {new Integer(option)});
	}

	X509Credential cred = null;
	try {
	    cred = new X509Credential(input);
	} catch(CredentialException e) {
	    throw new GlobusGSSException(GSSException.DEFECTIVE_CREDENTIAL, e);
	} catch (Exception e) {
	    throw new GlobusGSSException(GSSException.DEFECTIVE_CREDENTIAL, e);
	}

	return new GlobusGSSCredentialImpl(cred, usage);
    }
145150
public GoogRequire merge(GoogRequire other) {
    checkArgument(other.symbol().equals(symbol()));
    if (other.equals(this)) {
      return this;
    }
    // if symbols are equal and the references are, then they must differ only by requireType or not
    // prefer the non requireType symbol
    if ((other.chunk() instanceof VariableDeclaration
            && chunk() instanceof VariableDeclaration
            && ((VariableDeclaration) chunk())
                .varName()
                .equals(((VariableDeclaration) other.chunk()).varName()))
        || (!(chunk() instanceof VariableReference)
            && !(other.chunk() instanceof VariableDeclaration))) {
      if (other.isTypeRequire()) {
        return this;
      }
      return other;
    }
    throw new IllegalArgumentException(
        "Found the same namespace added as a require in multiple incompatible ways: "
            + other
            + " vs. "
            + this);
  }
275992
public static Command newQuery(String identifier,
                                   String name) {
        return getCommandFactoryProvider().newQuery( identifier,
                                                     name );

    }
777714
@Override
	public void require(int type, String namespace, String name) throws KriptonRuntimeException, IOException {
		if (type != this.type || (namespace != null && !namespace.equals(getNamespace())) || (name != null && !name.equals(getName()))) {
			throw new KriptonRuntimeException("expected: " + TYPES[type] + " {" + namespace + "}" + name, true, this.getLineNumber(), this.getColumnNumber(), getPositionDescription(), null);
		}
	}
329248
Node createThisAliasReferenceForFunction(String aliasName, Node functionNode) {
    final Node result = IR.name(aliasName);
    if (isAddingTypes()) {
      result.setJSType(getTypeOfThisForFunctionNode(functionNode));
    }
    return result;
  }
967826
public static Property newFrom(String name, String base, String prefix)
  {
    return new Property(name, base, prefix, null);
  }
691342
function closureRequire(symbol) {
  closure.goog.require(symbol);
  return closure.goog.getObjectByName(symbol);
}