Creates an IGosuParser appropriate for parsing and executing Gosu.

@param symTable          The symbol table the parser uses to parse and execute script.
@return A parser appropriate for parsing Gosu source.
492163
public IGosuParser createParser(
    ISymbolTable symTable, IScriptabilityModifier scriptabilityConstraint )
  {
    IGosuParser parser = new GosuParser( symTable, scriptabilityConstraint );
    return parser;
  }
1031754
public void createAbout(String name, String version, String targetGoVersion, String description) {
        about = new GoPluginDescriptor.About(name, version, targetGoVersion, description, vendor, targetOperatingSystems);
    }
778049
@Nullable
  private static SoyType getSoyTypeFromUnionForBinaryOperator(
      UnionType t0, SoyType t1, boolean isNullable, SoyTypeBinaryOperator operator) {
    List<SoyType> subTypes = new ArrayList<>();
    for (SoyType unionMember : t0.getMembers()) {
      SoyType result = getSoyTypeForBinaryOperator(unionMember, t1, operator);
      if (result == null) {
        return null;
      }
      subTypes.add(result);
    }
    SoyType result = UnionType.of(subTypes);
    return isNullable ? makeNullable(result) : result;
  }
426342
private static <X extends CopyableValue<X>> CopyableValueSerializer<X> createCopyableValueSerializer(Class<X> clazz) {
		return new CopyableValueSerializer<X>(clazz);
	}
555329
public OperatorTable<T> postfix(
      Parser<? extends Function<? super T, ? extends T>> parser, int precedence) {
    ops.add(new Operator(parser, precedence, Associativity.POSTFIX));
    return this;
  }
294311
public com.google.inject.Provider<org.eclipse.xtext.xtext.generator.parser.antlr.splitting.parser.antlr.internal.InternalSimpleExpressionsLexer> provideInternalSimpleExpressionsLexer() {
		return org.eclipse.xtext.parser.antlr.LexerProvider.create(org.eclipse.xtext.xtext.generator.parser.antlr.splitting.parser.antlr.internal.InternalSimpleExpressionsLexer.class);
	}
1005518
static void loadFromIterable(Context cx, Scriptable scope, ScriptableObject map, Object arg1)
    {
        if ((arg1 == null) || Undefined.instance.equals(arg1)) {
            return;
        }

        // Call the "[Symbol.iterator]" property as a function.
        final Object ito = ScriptRuntime.callIterator(arg1, cx, scope);
        if (Undefined.instance.equals(ito)) {
            // Per spec, ignore if the iterator is undefined
            return;
        }

        // Find the "add" function of our own prototype, since it might have
        // been replaced. Since we're not fully constructed yet, create a dummy instance
        // so that we can get our own prototype.
        ScriptableObject dummy = ensureScriptableObject(cx.newObject(scope, map.getClassName()));
        final Callable set =
                ScriptRuntime.getPropFunctionAndThis(dummy.getPrototype(), "set", cx, scope);
        ScriptRuntime.lastStoredScriptable(cx);

        // Finally, run through all the iterated values and add them!
        try (IteratorLikeIterable it = new IteratorLikeIterable(cx, scope, ito)) {
            for (Object val : it) {
                Scriptable sVal = ScriptableObject.ensureScriptable(val);
                if (sVal instanceof Symbol) {
                    throw ScriptRuntime.typeError1("msg.arg.not.object", ScriptRuntime.typeof(sVal));
                }
                Object finalKey = sVal.get(0, sVal);
                if (finalKey == NOT_FOUND) {
                    finalKey = Undefined.instance;
                }
                Object finalVal = sVal.get(1, sVal);
                if (finalVal == NOT_FOUND) {
                    finalVal = Undefined.instance;
                }
                set.call(cx, scope, map, new Object[] { finalKey, finalVal });
            }
        }
    }
221301
static SymbolTable newSharedSymbolTable(IonStruct ionRep)
    {
        IonReader reader = new IonReaderTreeSystem(ionRep);
        return newSharedSymbolTable(reader, false);
    }
655078
@Override
    public void syr(char order, char Uplo, int N, double alpha, INDArray X, INDArray A) {
        if (Nd4j.getExecutioner().getProfilingMode() == OpExecutioner.ProfilingMode.ALL)
            OpProfiler.getInstance().processBlasCall(false, A, X);

        // FIXME: int cast

        if (X.data().dataType() == DataType.DOUBLE) {
            DefaultOpExecutioner.validateDataType(DataType.DOUBLE, A, X);
            dsyr(order, Uplo, (int) X.length(), alpha, X, X.stride(-1), A, (int) A.size(0));
        } else {
            DefaultOpExecutioner.validateDataType(DataType.FLOAT, A, X);
            ssyr(order, Uplo, (int) X.length(), (float) alpha, X, X.stride(-1), A, (int) A.size(0));
        }

        OpExecutionerUtil.checkForAny(A);
    }
339910
public PTable makeNewPTable(FieldList record, Object lookupKey)
    {
        InputStream istream = null;
        try
        {
            if (lookupKey instanceof String)
                istream = this.openSerialStream(record, (String)lookupKey);
            if (istream != null)
            {
                ObjectInputStream q = new ObjectInputStream(istream);
                
                MTable sTable = (MTable)q.readObject();
                q.close();      // Is this necessary?
                sTable.init(this, record, lookupKey);
                return sTable;
            }
             
        } catch (Exception ex) {
        	System.out.println("Error " + ex.getMessage() + " on read serial file: " + lookupKey);
        	//+Util.getLogger().warning("Error " + ex.getMessage() + " on read serial file: " + lookupKey);
        } finally {
            try {
                if (istream != null)
                    istream.close();
            } catch (IOException e) {
            }            
        }
        return new MTable(this, record, lookupKey);   // New empty table
    }
1220138
@GwtIncompatible
    public static <T> Key<T> create( Class<? extends T> kindClass, String name ) {
        throw new UnsupportedOperationException();
    }
611537
public LSParser createLSParser() {
        LSParser parser = domImpl.createLSParser(DOMImplementationLS.MODE_SYNCHRONOUS, null);
        configureParser(parser);

        return parser;
    }
809683
@Override
    public Object unmarshal(Source source) throws IOException, XmlMappingException {
        if (source instanceof StAXSource) {
            source = fixStAXSource((StAXSource) source);
        }

        final Transformer identityTransformer;
        try {
            identityTransformer = this.xmlUtilities.getIdentityTransformer();
        } catch (TransformerConfigurationException e) {
            throw new RuntimeException("Failed to create identity Transformer", e);
        }

        final DOMResult domResult = new DOMResult();
        try {
            identityTransformer.transform(source, domResult);
        } catch (TransformerException e) {
            throw new RuntimeException("Failed to transform " + source + " into Document", e);
        }

        final Document resultDoc = (Document) domResult.getNode();
        return new Tuple<String, Document>(source.getSystemId(), resultDoc);
    }
1160143
@SuppressWarnings("unchecked")
    public static <T> ConnectableFlowable<T> createFrom(Flowable<? extends T> source) {
        Flowable<T> sourceCast = (Flowable<T>) source;
        return create(sourceCast, DEFAULT_UNBOUNDED_FACTORY);
    }
1090465
public final ImmutableListMultitable<R, C, V> loadToListMultitable(CharSource source)
      throws IOException {
    final ImmutableListMultitable.Builder<R, C, V> ret =
        ImmutableListMultitable.builder();

    loadToMultitable(source, ret);

    return ret.build();
  }
720325
public final boolean isAssignableFrom(SoyType srcType) {
    // Handle unions generically.  A type is assignable from a union if it is assignable from _all_
    // memebers.
    if (srcType instanceof UnionType) {
      // By construction union types are guaranteed
      // 1. not to be empty
      // 2. not to contain union types
      UnionType asUnion = (UnionType) srcType;
      for (SoyType member : asUnion.getMembers()) {
        if (!doIsAssignableFromNonUnionType(member)) {
          return false;
        }
      }
      return true;
    } else {
      return doIsAssignableFromNonUnionType(srcType);
    }
  }
1222227
@Nonnull
  public static UnifiedResponse createSimple (@Nonnull final HttpServletRequest aHttpRequest)
  {
    return new UnifiedResponse (RequestHelper.getHttpVersion (aHttpRequest),
                                RequestHelper.getHttpMethod (aHttpRequest),
                                aHttpRequest);
  }