25632886c8
This change further merges the new AST and MuPack/MuIL formats and
abstractions into the core of the compiler. A good amount of the old
code is gone now; I decided against ripping it all out in one fell
swoop so that I can methodically check that we are preserving all
relevant decisions and/or functionality we had in the old model.
The changes are too numerous to outline in this commit message,
however, here are the noteworthy ones:
* Split up the notion of symbols and tokens, resulting in:
- pkg/symbols for true compiler symbols (bound nodes)
- pkg/tokens for name-based tokens, identifiers, constants
* Several packages move underneath pkg/compiler:
- pkg/ast becomes pkg/compiler/ast
- pkg/errors becomes pkg/compiler/errors
- pkg/symbols becomes pkg/compiler/symbols
* pkg/ast/... becomes pkg/compiler/legacy/ast/...
* pkg/pack/ast becomes pkg/compiler/ast.
* pkg/options goes away, merged back into pkg/compiler.
* All binding functionality moves underneath a dedicated
package, pkg/compiler/binder. The legacy.go file contains
cruft that will eventually go away, while the other files
represent a halfway point between new and old, but are
expected to stay roughly in the current shape.
* All parsing functionality is moved underneath a new
pkg/compiler/metadata namespace, and we adopt new terminology
"metadata reading" since real parsing happens in the MetaMu
compilers. Hence, Parser has become metadata.Reader.
* In general phases of the compiler no longer share access to
the actual compiler.Compiler object. Instead, shared state is
moved to the core.Context object underneath pkg/compiler/core.
* Dependency resolution during binding has been rewritten to
the new model, including stashing bound package symbols in the
context object, and detecting import cycles.
* Compiler construction does not take a workspace object. Instead,
creation of a workspace is entirely hidden inside of the compiler's
constructor logic.
* There are three Compile* functions on the Compiler interface, to
support different styles of invoking compilation: Compile() auto-
detects a Mu package, based on the workspace; CompilePath(string)
loads the target as a Mu package and compiles it, regardless of
the workspace settings; and, CompilePackage(*pack.Package) will
compile a pre-loaded package AST, again regardless of workspace.
* Delete the _fe, _sema, and parsetree phases. They are no longer
relevant and the functionality is largely subsumed by the above.
...and so very much more. I'm surprised I ever got this to compile again!
25 lines
1.5 KiB
Go
25 lines
1.5 KiB
Go
// Copyright 2016 Marapongo, Inc. All rights reserved.
|
|
|
|
// The graph package defines MuGL graphs. Each graph is directed and acyclic, and the nodes have been topologically
|
|
// sorted based on dependencies (edges) between them. Each node in the graph has a type and a set of properties.
|
|
//
|
|
// There are two forms of graph: complete and incomplete. A complete graph is one in which all nodes and their property
|
|
// values are known. An incomplete graph is one where two uncertainties may arise: (1) an edge might be "conditional",
|
|
// indicating that its presence or absence is dependent on a piece of information not yet available (like an output
|
|
// property from a resource), and/or (2) a property may either be similarly conditional or computed as an output value.
|
|
//
|
|
// In general, Mu blueprints may be compiled into graphs. These graphs may then be compared to other graphs to produce
|
|
// and/or carry out deployment plans. This package therefore also exposes operations necessary for diffing graphs.
|
|
package graph
|
|
|
|
import (
|
|
"github.com/marapongo/mu/pkg/tokens"
|
|
)
|
|
|
|
// Graph is an instance of a MuGL graph. Each is associated with a single blueprint MuPackage as its input, along with
|
|
// a set of optional arguments used to evaluate it, along with the output DAG with node types and properties.
|
|
type Graph interface {
|
|
Pkg() tokens.Package // the blueprint package that this graph corresponds to.
|
|
Args() []interface{} // the parsed arguments used to instantiate this blueprint.
|
|
Root() Node // the root node in the graph.
|
|
}
|