How to use

TruffleLanguage$AccessAPI

in

com.oracle.truffle.api

/**
 * Returns the java host representation of a Truffle guest object if it represents a Java
 * host language object. Throws {@link ClassCastException} if the provided argument is not a
 * {@link #isHostObject(Object) host object}.
 *
 * @since 1.0
 */
public Object asHostObject(Object value) {
  if (!isHostObject(value)) {
    CompilerDirectives.transferToInterpreter();
    throw new ClassCastException();
  }
  return AccessAPI.engineAccess().asHostObject(value);
}

@Override
public Env createEnv(Object vmObject, TruffleLanguage<?> language, OutputStream stdOut, OutputStream stdErr, InputStream stdIn, Map<String, Object> config, OptionValues options,
        String[] applicationArguments, FileSystem fileSystem) {
  Env env = new Env(vmObject, language, stdOut, stdErr, stdIn, config, options, applicationArguments, fileSystem);
  LinkedHashSet<Object> collectedServices = new LinkedHashSet<>();
  LanguageInfo info = language.languageInfo;
  AccessAPI.instrumentAccess().collectEnvServices(collectedServices, API.nodes().getEngineObject(info), language);
  env.services = new ArrayList<>(collectedServices);
  return env;
}

/**
 * Set arguments of the scope.
 * <p>
 * The properties representing the arguments needs to have deterministic iteration order,
 * argument declaration order is recommended.
 *
 * @param arguments arguments of the scope
 * @since 0.30
 */
@SuppressWarnings("hiding")
public Builder arguments(Object arguments) {
  assert arguments == null || TruffleLanguage.AccessAPI.interopAccess().isTruffleObject(arguments) : Objects.toString(arguments);
  this.arguments = arguments;
  return this;
}

SourceSection findSourceLocation(Object obj) {
  Object c = getLanguageContext();
  if (c != UNSET_CONTEXT) {
    final Object rawValue = AccessAPI.engineAccess().findOriginalObject(obj);
    return spi.findSourceLocation(c, rawValue);
  } else {
    return null;
  }
}

static InstrumentSupport instrumentAccess() {
  return API.instrumentSupport();
}

/**
 * Looks up a Java class in the top-most scope the host environment. Throws an error if no
 * symbol was found or the symbol was not accessible. Symbols might not be accessible if a
 * {@link org.graalvm.polyglot.Context.Builder#hostClassFilter(java.util.function.Predicate)
 * class filter} prevents access. The returned object is always a <code>TruffleObject</code>
 * .
 *
 * @param symbolName the name of the symbol in the the host language.
 * @since 0.27
 */
@TruffleBoundary
public Object lookupHostSymbol(String symbolName) {
  return AccessAPI.engineAccess().lookupHostSymbol(vmObject, this, symbolName);
}

@Override
public boolean isThreadAccessAllowed(LanguageInfo language, Thread thread, boolean singleThread) {
  return AccessAPI.nodesAccess().getLanguageSpi(language).isThreadAccessAllowed(thread, singleThread);
}

static InteropSupport interopAccess() {
  return API.interopSupport();
}

static InteropSupport interopAccess() {
  return API.interopSupport();
}

static EngineSupport engineAccess() {
  return API.engineSupport();
}

static EngineSupport engineAccess() {
  return API.engineSupport();
}

static Nodes nodesAccess() {
  return API.nodes();
}

/**
 * Leaves this context and sets the previous context as the new current context.
 * <p>
 * Leaving a language context is designed for compilation and is most efficient if the
 * {@link TruffleContext context} instance is compilation final.
 *
 * @param prev the previous context returned by {@link #enter()}
 * @see #enter()
 * @since 0.27
 */
public void leave(Object prev) {
  assert verifyLeave(prev);
  AccessAPI.engineAccess().leaveInternalContext(impl, prev);
}

boolean isObjectOfLanguage(Object obj) {
  final Object rawValue = AccessAPI.engineAccess().findOriginalObject(obj);
  return spi.isObjectOfLanguage(rawValue);
}

static InstrumentSupport instrumentAccess() {
  return API.instrumentSupport();
}

@Override
@SuppressWarnings("rawtypes")
public LanguageInfo getLegacyLanguageInfo(Object vm, Class<? extends TruffleLanguage> languageClass) {
  if (vm == null) {
    return null;
  }
  Env env = AccessAPI.engineAccess().findEnv(vm, languageClass, false);
  if (env != null) {
    return env.language;
  } else {
    return null;
  }
}

/**
 * Returns the current language instance for the current {@link Thread thread}. If a root node
 * is accessible then {@link RootNode#getLanguage(Class)} should be used instead. Throws an
 * {@link IllegalStateException} if the language is not yet initialized or not executing on this
 * thread. If invoked on the fast-path then <code>languageClass</code> must be a compilation
 * final value.
 *
 * @param <T> the language type
 * @param languageClass the exact language class needs to be provided for the lookup.
 * @since 0.27
 */
protected static <T extends TruffleLanguage<?>> T getCurrentLanguage(Class<T> languageClass) {
  return AccessAPI.engineAccess().getCurrentLanguage(languageClass);
}

/**
 * Allows it to be determined if this {@link org.graalvm.polyglot.Context} can execute code
 * written in a language with a given MIME type.
 *
 * @see Source#getMimeType()
 * @see #parse(Source, String...)
 *
 * @return a boolean that indicates if the MIME type is supported
 * @since 0.11
 */
@TruffleBoundary
public boolean isMimeTypeSupported(String mimeType) {
  checkDisposed();
  return AccessAPI.engineAccess().isMimeTypeSupported(vmObject, mimeType);
}

/**
 * Adds an entry to the Java host class loader. All classes looked up with
 * {@link #lookupHostSymbol(String)} will lookup classes with this new entry. If the entry
 * was already added then calling this method again for the same entry has no effect. Given
 * entry must not be <code>null</code>.
 *
 * @throws SecurityException if the file is not {@link TruffleFile#isReadable() readable}.
 * @since 1.0
 */
@TruffleBoundary
public void addToHostClassPath(TruffleFile entry) {
  Objects.requireNonNull(entry);
  AccessAPI.engineAccess().addToHostClassPath(vmObject, entry);
}

/**
 * Returns a map mime-type to language instance of all languages that are installed in the
 * environment. Using the language instance additional services can be
 * {@link #lookup(LanguageInfo, Class) looked up} .
 *
 * @since 0.26
 */
@TruffleBoundary
public Map<String, LanguageInfo> getLanguages() {
  return AccessAPI.engineAccess().getLanguages(vmObject);
}