Initial commit

Author: pkedy

README.md

@@ -0,0 +1,13 @@
+# WebAssembly Interface Definition Language (WIDL) for Golang
+
+WIDL is a schema format for describing [waPC](https://github.com/wapc) modules and used by the [CLI](https://github.com/wapc/cli) to generate code for the supported guest languages. It heavily resembles [GraphQL schema](https://graphql.org/learn/schema/) but with some variations to fit better in the WebAssembly ecosystem.
+
+* Built-in WebAssembly numeric types (i8-64, i8-64, f32, f64) - no scalars required
+* Scalars explicitly alias a known type
+* Functions can return `void` instead of returning `Boolean` as a workaround
+* Fields are required by default instead of optional and `?` is used after the field name to denote that it is optional
+* Support for maps
+* Operations are defined in a single interface instead of separating query and mutation operations
+* Removed the concepts that do not apply from GraphQL schema (e.g. Queries vs. Mutations, Field arguments, Variables, Fragments)
+
+Everything in this package was borrowed and retrofitted from the awesome [Golang GraphQL library](https://github.com/graphql-go/graphql).  We thank the 70+ contributors to this project! It has enabled us to provide a succinct interface definition language to our users with minimal effort.

errors/error.go

@@ -0,0 +1,78 @@
+package errors
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/wapc/widl-go/language/ast"
+	"github.com/wapc/widl-go/language/location"
+	"github.com/wapc/widl-go/language/source"
+)
+
+type Error struct {
+	Message       string
+	Stack         string
+	Nodes         []ast.Node
+	Source        *source.Source
+	Positions     []int
+	Locations     []location.SourceLocation
+	OriginalError error
+	Path          []interface{}
+}
+
+// implements Golang's built-in `error` interface
+func (g Error) Error() string {
+	return fmt.Sprintf("%v", g.Message)
+}
+
+func NewError(message string, nodes []ast.Node, stack string, source *source.Source, positions []int, origError error) *Error {
+	return newError(message, nodes, stack, source, positions, nil, origError)
+}
+
+func NewErrorWithPath(message string, nodes []ast.Node, stack string, source *source.Source, positions []int, path []interface{}, origError error) *Error {
+	return newError(message, nodes, stack, source, positions, path, origError)
+}
+
+func newError(message string, nodes []ast.Node, stack string, source *source.Source, positions []int, path []interface{}, origError error) *Error {
+	if stack == "" && message != "" {
+		stack = message
+	}
+	if source == nil {
+		for _, node := range nodes {
+			// get source from first node
+			if node == nil || reflect.ValueOf(node).IsNil() {
+				continue
+			}
+			if node.GetLoc() != nil {
+				source = node.GetLoc().Source
+			}
+			break
+		}
+	}
+	if len(positions) == 0 && len(nodes) > 0 {
+		for _, node := range nodes {
+			if node == nil || reflect.ValueOf(node).IsNil() {
+				continue
+			}
+			if node.GetLoc() == nil {
+				continue
+			}
+			positions = append(positions, node.GetLoc().Start)
+		}
+	}
+	locations := []location.SourceLocation{}
+	for _, pos := range positions {
+		loc := location.GetLocation(source, pos)
+		locations = append(locations, loc)
+	}
+	return &Error{
+		Message:       message,
+		Stack:         stack,
+		Nodes:         nodes,
+		Source:        source,
+		Positions:     positions,
+		Locations:     locations,
+		OriginalError: origError,
+		Path:          path,
+	}
+}

errors/syntax.go

@@ -0,0 +1,69 @@
+package errors
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+
+	"github.com/wapc/widl-go/language/ast"
+	"github.com/wapc/widl-go/language/location"
+	"github.com/wapc/widl-go/language/source"
+)
+
+func NewSyntaxError(s *source.Source, position int, description string) *Error {
+	l := location.GetLocation(s, position)
+	return NewError(
+		fmt.Sprintf("Syntax Error %s (%d:%d) %s\n\n%s", s.Name, l.Line, l.Column, description, highlightSourceAtLocation(s, l)),
+		[]ast.Node{},
+		"",
+		s,
+		[]int{position},
+		nil,
+	)
+}
+
+// printCharCode here is slightly different from lexer.printCharCode()
+func printCharCode(code rune) string {
+	// print as ASCII for printable range
+	if code >= 0x0020 {
+		return fmt.Sprintf(`%c`, code)
+	}
+	// Otherwise print the escaped form. e.g. `"\\u0007"`
+	return fmt.Sprintf(`\u%04X`, code)
+}
+func printLine(str string) string {
+	strSlice := []string{}
+	for _, runeValue := range str {
+		strSlice = append(strSlice, printCharCode(runeValue))
+	}
+	return fmt.Sprintf(`%s`, strings.Join(strSlice, ""))
+}
+func highlightSourceAtLocation(s *source.Source, l location.SourceLocation) string {
+	line := l.Line
+	prevLineNum := fmt.Sprintf("%d", (line - 1))
+	lineNum := fmt.Sprintf("%d", line)
+	nextLineNum := fmt.Sprintf("%d", (line + 1))
+	padLen := len(nextLineNum)
+	lines := regexp.MustCompile("\r\n|[\n\r]").Split(string(s.Body), -1)
+	var highlight string
+	if line >= 2 {
+		highlight += fmt.Sprintf("%s: %s\n", lpad(padLen, prevLineNum), printLine(lines[line-2]))
+	}
+	highlight += fmt.Sprintf("%s: %s\n", lpad(padLen, lineNum), printLine(lines[line-1]))
+	for i := 1; i < (2 + padLen + l.Column); i++ {
+		highlight += " "
+	}
+	highlight += "^\n"
+	if line < len(lines) {
+		highlight += fmt.Sprintf("%s: %s\n", lpad(padLen, nextLineNum), printLine(lines[line]))
+	}
+	return highlight
+}
+
+func lpad(l int, s string) string {
+	var r string
+	for i := 1; i < (l - len(s) + 1); i++ {
+		r += " "
+	}
+	return r + s
+}

go.mod

@@ -0,0 +1,3 @@
+module github.com/wapc/widl-go
+
+go 1.15

language/ast/annotations.go

@@ -0,0 +1,33 @@
+package ast
+
+import (
+	"github.com/wapc/widl-go/language/kinds"
+)
+
+// Annotation implements Node
+type Annotation struct {
+	Kind      string
+	Loc       *Location
+	Name      *Name
+	Arguments []*Argument
+}
+
+func NewAnnotation(an *Annotation) *Annotation {
+	if an == nil {
+		an = &Annotation{}
+	}
+	return &Annotation{
+		Kind:      kinds.Annotation,
+		Loc:       an.Loc,
+		Name:      an.Name,
+		Arguments: an.Arguments,
+	}
+}
+
+func (an *Annotation) GetKind() string {
+	return an.Kind
+}
+
+func (an *Annotation) GetLoc() *Location {
+	return an.Loc
+}

language/ast/arguments.go

@@ -0,0 +1,29 @@
+package ast
+
+import (
+	"github.com/wapc/widl-go/language/kinds"
+)
+
+// Argument implements Node
+type Argument struct {
+	Kind  string
+	Loc   *Location
+	Name  *Name
+	Value Value
+}
+
+func NewArgument(arg *Argument) *Argument {
+	if arg == nil {
+		arg = &Argument{}
+	}
+	arg.Kind = kinds.Argument
+	return arg
+}
+
+func (arg *Argument) GetKind() string {
+	return arg.Kind
+}
+
+func (arg *Argument) GetLoc() *Location {
+	return arg.Loc
+}

language/ast/definitions.go

@@ -0,0 +1,49 @@
+package ast
+
+import (
+	"github.com/wapc/widl-go/language/kinds"
+)
+
+type Definition interface {
+	GetKind() string
+	GetLoc() *Location
+}
+
+// Ensure that all definition types implements Definition interface
+var _ Definition = (TypeSystemDefinition)(nil) // experimental non-spec addition.
+
+// AnnotationDefinition implements Node, Definition
+type AnnotationDefinition struct {
+	Kind        string
+	Loc         *Location
+	Name        *Name
+	Description *StringValue
+	Arguments   []*InputValueDefinition
+	Locations   []*Name
+}
+
+func NewAnnotationDefinition(def *AnnotationDefinition) *AnnotationDefinition {
+	if def == nil {
+		def = &AnnotationDefinition{}
+	}
+	return &AnnotationDefinition{
+		Kind:        kinds.AnnotationDefinition,
+		Loc:         def.Loc,
+		Name:        def.Name,
+		Description: def.Description,
+		Arguments:   def.Arguments,
+		Locations:   def.Locations,
+	}
+}
+
+func (def *AnnotationDefinition) GetKind() string {
+	return def.Kind
+}
+
+func (def *AnnotationDefinition) GetLoc() *Location {
+	return def.Loc
+}
+
+func (def *AnnotationDefinition) GetDescription() *StringValue {
+	return def.Description
+}

language/ast/document.go

@@ -0,0 +1,31 @@
+package ast
+
+import (
+	"github.com/wapc/widl-go/language/kinds"
+)
+
+// Document implements Node
+type Document struct {
+	Kind        string
+	Loc         *Location
+	Definitions []Node
+}
+
+func NewDocument(d *Document) *Document {
+	if d == nil {
+		d = &Document{}
+	}
+	return &Document{
+		Kind:        kinds.Document,
+		Loc:         d.Loc,
+		Definitions: d.Definitions,
+	}
+}
+
+func (node *Document) GetKind() string {
+	return node.Kind
+}
+
+func (node *Document) GetLoc() *Location {
+	return node.Loc
+}

language/ast/location.go

@@ -0,0 +1,22 @@
+package ast
+
+import (
+	"github.com/wapc/widl-go/language/source"
+)
+
+type Location struct {
+	Start  int
+	End    int
+	Source *source.Source
+}
+
+func NewLocation(loc *Location) *Location {
+	if loc == nil {
+		loc = &Location{}
+	}
+	return &Location{
+		Start:  loc.Start,
+		End:    loc.End,
+		Source: loc.Source,
+	}
+}

language/ast/name.go

@@ -0,0 +1,28 @@
+package ast
+
+import (
+	"github.com/wapc/widl-go/language/kinds"
+)
+
+// Name implements Node
+type Name struct {
+	Kind  string
+	Loc   *Location
+	Value string
+}
+
+func NewName(node *Name) *Name {
+	if node == nil {
+		node = &Name{}
+	}
+	node.Kind = kinds.Name
+	return node
+}
+
+func (node *Name) GetKind() string {
+	return node.Kind
+}
+
+func (node *Name) GetLoc() *Location {
+	return node.Loc
+}