How to use Result.transpiledFiles?

[KOLANICH]

Here is my code, but it seems that Result.transpiledFiles are always empty (in my scenario, see the test).

Should I get the results into Result.transpiledFiles instead of compiler.toSource() and what should I do for it?

[niloc132]

It might be easier if you started with a Java program, rather than bridging between python and Java.

In my experience, the command line options are deceptively simple compared to how flexible the Compiler class is. I've found it is nearly impossible to use it without first starting from the command line runner, figuring out what kinds of options it would have created, and what each of those options would have done to the Compiler to produce what you expected, and only they start tweaking things in ways that are impossible with the command line...

With that said, poking quickly at the Java sources where result.transppiled files is read, for example:

closure-compiler/src/com/google/javascript/jscomp/transpile/BaseTranspiler.java

Lines 131 to 150 in 027f5e6

	public CompileResult compile(URI path, String code) {
	Compiler compiler = compiler();
	Result result =
	compiler.compile(
	createTrivialExterns(), SourceFile.fromCode(path.toString(), code), options());
	String source = compiler.toSource();
	StringBuilder sourceMap = new StringBuilder();
	if (result.sourceMap != null) {
	try {
	result.sourceMap.appendTo(sourceMap, path.toString());
	} catch (IOException e) {
	// impossible, and not a big deal even if it did happen.
	}
	}
	boolean transpiled = !result.transpiledFiles.isEmpty();
	if (!result.errors.isEmpty()) {
	throw new TranspilationException(compiler, result.errors, result.warnings);
	}
	return new CompileResult(source, transpiled, transpiled ? sourceMap.toString() : "");
	}

and (this one indirectly):

closure-compiler/src/com/google/javascript/jscomp/bundle/CompilerBasedTransformer.java

Lines 96 to 112 in 027f5e6

	public CompileResult compile(Path path, String code) {
	Compiler compiler = compiler();
	Result result =
	compiler.compile(EXTERNS, SourceFile.fromCode(path.toString(), code), options());
	String source = compiler.toSource();
	StringBuilder sourceMap = new StringBuilder();
	if (result.sourceMap != null) {
	try {
	result.sourceMap.appendTo(sourceMap, path.toString());
	} catch (IOException e) {
	// impossible, and not a big deal even if it did happen.
	}
	}
	boolean transformed = transformed(result);
	return new CompileResult(
	source, result.errors, transformed, transformed ? sourceMap.toString() : "");
	}

In both cases, the compiler isn't optimizing, but just transpiling - as the name suggests. As such, you probably don't want this, if your implementation of createCompiler options is what you actually want
https://github.com/KOLANICH-libs/ClosureCompiler.py/blob/a6ffe19fd7305469ec612267a2308e88762849f4/ClosureCompiler/lowLevel.py#L187

As I understand it, this is mostly/only used for BUNDLE code, to rewrite es6 modules into something that can be inlined into a single output JS file.

In contrast, you're probably after either a single output file, or the initial file and its corresponding chunks? If so, looking at how the command line runner walks the specified chunks then calls compiler.getSourceFileByName(name) for each. Note that getSourceFileByName is package-protected, so you probably would use getSourceFileContentByName instead for that purpose.

Compiler.toSource() is what the command line runner calls on at least a few code paths, so could well be what you actually want to call.

[KOLANICH]

I've found it is nearly impossible to use it without first starting from the command line runner, figuring out what kinds of options it would have created, and what each of those options would have done to the Compiler to produce what you expected, and only they start tweaking things in ways that are impossible with the command line...

Yeah, I did the same.

poking quickly at the Java sources where result.transpiledFiles is read

I have also poked, and found nothing useful. I mean I have tried different options set in those context, but still get an empty array.

But thanks for the info.

It feels like that prop is used only when outputting legacy versions of ECMAScript is requested. The following snippet

from ClosureCompiler import *
from ClosureCompiler.lowLevel import *

c = Compiler(createCompilerOptions(
    languageOut = ji.CompileLanguageMode.ECMASCRIPT5,
))
res = c({
    "a.jsm": "export const asdf = 'aaaa'; alert('1 ' + asdf);",
})
r = c.compiler.getResult()
s = list(r.transpiledFiles)[0]
print("s.getCode()", repr(str(s.getCode())))
print("res.files[None]", repr(res.files[None]))  # res is my object

causes transpiledFiles to be populated, but with vanilla source code:

s.getCode() "export const asdf = 'aaaa'; alert('1 ' + asdf);"
res.files[None] '\'use strict\';\nalert("1 aaaa");\n'

so transpiledFiles are not results, but inputs. In fact they are the same objects:

reproducing code

# https://repo.maven.apache.org/maven2/org/openjdk/jol/jol-core/0.17/jol-core-0.17.jar was added into the classpath and "org.openjdk.jol.vm.VM" was added into imported classes

from ClosureCompiler.lowLevel import *

options = createCompilerOptions(
    languageOut = ji.CompileLanguageMode.ECMASCRIPT5,
)

sources = convertSourcesMapping({
    "a.jsm": "export const asdf = 'aaaa'; alert('1 ' + asdf);",
})

builtinExterns = getBuiltInExterns(options.getEnvironment())

compiler = ji.Compiler()
lowLevelRes = compiler.compile(
    ji.ArrayList(builtinExterns),
    ji.ArrayList(sources),
    options,
)

if not lowLevelRes.success:
    raise Exception("Transpilation has failed, see the cli output for now")

s = list(lowLevelRes.transpiledFiles)[0]
vm = ji.VM.current()
vm.addressOf(s) == vm.addressOf(sources[0]) # True

In contrast, you're probably after either a single output file, or the initial file and its corresponding chunks?

In fact I assumed that the Closure Compiler optimizes each input taking in account the info from other inputs (kinda like externs do, but preserving only keeping the stuff that is determined to be used), but keeping the results a bit separately in different com.google.javascript.jscomp.SourceFiles. It seems that currently Closure Compiler doesn't do it itself, but it can probably be solved by multiple compiling calls with compiling one file at time and keeping the rest as externs.

[niloc132]

It feels like that prop is used only when outputting legacy versions of ECMAScript is requested.

Yes, that is what I was trying to convey. Odds are, you don't want this, unless you have es6 module inputs, and, without optimizing them, want to output them directly. For example, compilationLevel=BUNDLE will combine all JS files into one without any optimizations, and in order to achieve that any imports and exports need to be rewritten into references to other files that have been sent.

In fact I assumed that the Closure Compiler optimizes each input taking in account the info from other inputs (kinda like externs do, but preserving only keeping the stuff that is determined to be used), but keeping the results a bit separately in different com.google.javascript.jscomp.SourceFiles.

I don't think you would want this. This would prevent inlining from one file to another from occurring, among other things. The compiler doesn't stop at "treeshaking", but is capable of substantially more than that, which blurs the lines between files.

[KOLANICH]

I don't think you would want this. This would prevent inlining from one file to another from occurring, among other things. The compiler doesn't stop at "treeshaking", but is capable of substantially more than that, which blurs the lines between files.

Yeah, I know. I just assumed it having such a capability, so wanted to expose it through my bindings too.