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.
|
|
}
|