This change introduces basic class lowering into MuPack/MuIL. There are
a handful of things not yet supported (like extends/implements and properties),
however, simple methods and variables are supported.
This change introduces lowering for function definitions and parameters.
This includes a few tests for both exported and unexported module-level
function definitions. Class members will come shortly...
This change properly retains and emits the desired accessibility for
module properties, based on whether a property has been exported or not.
It also updates the existing export property test baseline and adds
another one for unexported module properties.
This change uses paths relative to the compilation root context path,
so that they aren't absolute and therefore aren't tied to a specific
machine. This fixesmarapongo/mu#42, and cleans up our test baselines.
Per marapongo/mu#42, this change shortens module names to be more "Mu-like"
and to reflect the relative module paths. There is still awkwardness if there
are any "up and over" references, i.e. using "..", but this handles the 95%
case. We still don't mark entrypoints, but this gets us one step closer.
This change adds discovery of Mu metadata in the form of a Mu.json file.
This allows us to eliminate the "TODO" in place of a real package name in
the output ASTs, so our baselines are adjusted accordingly. This is part
of marapongo/mu#42 -- implementation of real module and package names.
This changes the test harness to do a line-by-line comparison, rather than
full text comparison, for AST checking. This is a bit nicer to diagnose, because
failures will specifically point out the line that deviates, rather than dumping
the (possibly huge) string containing the full expected/actual ASTs.
This adds a baseline for the empty module test, and it passes.
Unfortunately, because module names are absolute file paths, this
baseline file has my machine's specific path embedded in it. I want
to lock these in so they are passing as I make progress. Sometime
later this morning I'll fix the module naming to be "relative" and
more Mu-friendly, and this issue will go away.
For now we will use the module's fileName as its name. This matches
the ECMAScript semantics, however, we will eventually want to do a pass
to normalize these names into more "Mu-friendly" module names.
This changes the way we represent identifiers slightly, and then lowers
the TypeScript representation to them. Prior to this change, identifiers
could be naked strings; after this change, identifiers are always first class
AST nodes -- so they can carry location information -- and tokens assume the
role of naked strings. This means some definition maps must now be keyed by
tokens and also means that some AST node properties that used to carry just
naked strings needed to be updated to carry first class AST nodes.
This is an initial cut at implementing variable declaration lowering.
The lowering is slightly different for module properties and local variables,
since the former requires that code go into the module initializer, while the
latter can mostly happen "inline" as the local variable is bound.
There are some incomplete parts in here -- like lowering type names -- that
are dependent on a few upcoming changes.
This change translates MuJS modules and their various top-level statements
into the corresponding MuPack/MuIL metadata. Notably, to ensure static analyzability,
MuIL doesn't permit arbitrary class, function, etc. definitions as statements. Instead,
they must occur at the top-level, and be recognized as such statically. That's the bulk
of this change. The individual nodes aren't necessarily mapped yet, however.
The way ECMAScript and Python work is that each file maps to a module. There
isn't really an "official" notion of a submodule; instead, directories on the
import path are conventionally used as submodule names. Aggregate submodules
can be achieved by convention with re-exports in ECMAScript, however this is an
informal notion. We could keep the current structured submodule notion and require
that all languages map to it, however, it is just as easy to have a flat list of
top-level modules indexed by name. This change rearranges the AST accordingly.
This adds a new test harness that will be used to run baseline-style
tests. Each subdirectory underneath tests/output will be interpreted as
a test case, each of which can contain an optional `messages.txt` file
which will be compared as the expected output against the compiler's error
and warning messages, and/or an optional `Mu.out.json` file which will be
compared as the expected output against the compiler's output tree.
There's just a single "empty" test case for now. I will start getting in
the habit of checking in a companion test for each AST kind we lower.
This adds two expressions we will need to support many type test patterns.
IsInst simply checks an expression for castability to a target type; it evaluates
to a boolean.
TypeOf fetches the runtime type of a given expression and evaluates to its name.
Right now, this is just a string token, rather than some richer RTTI object.
This is mostly boilerplate, mapping the following AST kinds: IfStatement,
ReturnStatement, ThrowStatement, Block, EmptyStatement, ExpressionStatement,
and LabeledStatement.
The stacks.md document used to describe the metadata format. Now that we've
moved away from the old model of YAML + Go templates, and created the MuPack/MuIL
format, this document needed to be overhauled.
It's pretty bare bones now, however it will eventually evolve into a document
describing how the Mu abstractions map down onto MuPack/MuIL concepts. For example,
it describes how subclassing mu.Stack creates a "stack", even though at the MuPack/MuIL
level it's just any old subclass.
Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.
But if it had to perish twice,
I think I know enough of hate
To say that for destruction ice
Is also great
And would suffice.
