removing the internal dir

internal/ast/expressions.go → ast/expressions.go

@@ -5,7 +5,7 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/dfirebaugh/punch/internal/token"
+	"github.com/dfirebaugh/punch/token"
 )
 
 type Identifier struct {
@@ -150,6 +150,7 @@ func (pe *PrefixExpression) TokenLiteral() string {
 	}
 	return pe.TokenLiteral()
 }
+
 func (pe *PrefixExpression) String() string {
 	var out bytes.Buffer
 

internal/ast/function.go → ast/function.go

@@ -4,7 +4,7 @@ import (
 	"bytes"
 	"strings"
 
-	"github.com/dfirebaugh/punch/internal/token"
+	"github.com/dfirebaugh/punch/token"
 )
 
 type Parameter struct {

internal/ast/literals.go → ast/literals.go

@@ -5,7 +5,7 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/dfirebaugh/punch/internal/token"
+	"github.com/dfirebaugh/punch/token"
 )
 
 type IntegerLiteral struct {

internal/ast/statements.go → ast/statements.go

@@ -3,7 +3,7 @@ package ast
 import (
 	"bytes"
 
-	"github.com/dfirebaugh/punch/internal/token"
+	"github.com/dfirebaugh/punch/token"
 )
 
 type ExpressionStatement struct {

internal/ast/struct.go → ast/struct.go

@@ -4,7 +4,7 @@ import (
 	"bytes"
 	"strings"
 
-	"github.com/dfirebaugh/punch/internal/token"
+	"github.com/dfirebaugh/punch/token"
 )
 
 type StructField struct {

cmd/punch/main.go

@@ -7,9 +7,9 @@ import (
 	"os"
 	"os/exec"
 
-	"github.com/dfirebaugh/punch/internal/emitters/js"
-	"github.com/dfirebaugh/punch/internal/lexer"
-	"github.com/dfirebaugh/punch/internal/parser"
+	"github.com/dfirebaugh/punch/emitters/js"
+	"github.com/dfirebaugh/punch/lexer"
+	"github.com/dfirebaugh/punch/parser"
 )
 
 func main() {

cmd/repl/repl.go

@@ -5,7 +5,7 @@ import (
 	"os"
 	"os/user"
 
-	"github.com/dfirebaugh/punch/internal/repl"
+	"github.com/dfirebaugh/punch/repl"
 )
 
 func main() {

internal/compiler/compiler.go → compiler/compiler.go

@@ -2,9 +2,9 @@ package compiler
 
 import (
 	"github.com/bytecodealliance/wasmtime-go"
-	"github.com/dfirebaugh/punch/internal/emitters/wat"
-	"github.com/dfirebaugh/punch/internal/lexer"
-	"github.com/dfirebaugh/punch/internal/parser"
+	"github.com/dfirebaugh/punch/emitters/wat"
+	"github.com/dfirebaugh/punch/lexer"
+	"github.com/dfirebaugh/punch/parser"
 )
 
 const (

internal/emitters/js/js.go → emitters/js/js.go

@@ -5,8 +5,8 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/dfirebaugh/punch/internal/ast"
-	"github.com/dfirebaugh/punch/internal/token"
+	"github.com/dfirebaugh/punch/ast"
+	"github.com/dfirebaugh/punch/token"
 )
 
 const (

internal/emitters/wat/function.go → emitters/wat/function.go

@@ -5,7 +5,7 @@ import (
 	"log"
 	"strings"
 
-	"github.com/dfirebaugh/punch/internal/ast"
+	"github.com/dfirebaugh/punch/ast"
 )
 
 var (

internal/emitters/wat/wat.go → emitters/wat/wat.go

@@ -5,8 +5,8 @@ import (
 	"log"
 	"strings"
 
-	"github.com/dfirebaugh/punch/internal/ast"
-	"github.com/dfirebaugh/punch/internal/token"
+	"github.com/dfirebaugh/punch/ast"
+	"github.com/dfirebaugh/punch/token"
 )
 
 const (

examples/struct.pun

@@ -1,4 +1,3 @@
-
 pkg main
 
 struct extra {

internal/lexer/collector.go → lexer/collector.go

@@ -1,6 +1,6 @@
 package lexer
 
-import "github.com/dfirebaugh/punch/internal/token"
+import "github.com/dfirebaugh/punch/token"
 
 type Collector struct {
 	result []token.Token
@@ -9,6 +9,7 @@ type Collector struct {
 func (c *Collector) Collect(t token.Token) {
 	c.result = append(c.result, t)
 }
+
 func (c *Collector) Result() []token.Token {
 	return c.result
 }

internal/lexer/lexer.go → lexer/lexer.go

@@ -4,7 +4,7 @@ import (
 	"strings"
 	"text/scanner"
 
-	"github.com/dfirebaugh/punch/internal/token"
+	"github.com/dfirebaugh/punch/token"
 )
 
 type Lexer struct {

internal/lexer/lexer_external_test.go → lexer/lexer_external_test.go

@@ -3,8 +3,8 @@ package lexer_test
 import (
 	"testing"
 
-	"github.com/dfirebaugh/punch/internal/lexer"
-	"github.com/dfirebaugh/punch/internal/token"
+	"github.com/dfirebaugh/punch/lexer"
+	"github.com/dfirebaugh/punch/token"
 )
 
 func TestLexer(t *testing.T) {

internal/lexer/lexer_test.go → lexer/lexer_test.go

@@ -5,7 +5,7 @@ import (
 	"testing"
 	"text/scanner"
 
-	"github.com/dfirebaugh/punch/internal/token"
+	"github.com/dfirebaugh/punch/token"
 )
 
 type testCollector struct{}

internal/parser/errors.go → parser/errors.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/dfirebaugh/punch/internal/token"
+	"github.com/dfirebaugh/punch/token"
 	"github.com/sirupsen/logrus"
 )
 

internal/parser/function.go → parser/function.go

@@ -3,8 +3,8 @@ package parser
 import (
 	"fmt"
 
-	"github.com/dfirebaugh/punch/internal/ast"
-	"github.com/dfirebaugh/punch/internal/token"
+	"github.com/dfirebaugh/punch/ast"
+	"github.com/dfirebaugh/punch/token"
 )
 
 func (p *Parser) parseFunctionStatement() *ast.FunctionStatement {

internal/parser/parser.go → parser/parser.go

@@ -1,9 +1,9 @@
 package parser
 
 import (
-	"github.com/dfirebaugh/punch/internal/ast"
-	"github.com/dfirebaugh/punch/internal/lexer"
-	"github.com/dfirebaugh/punch/internal/token"
+	"github.com/dfirebaugh/punch/ast"
+	"github.com/dfirebaugh/punch/lexer"
+	"github.com/dfirebaugh/punch/token"
 )
 
 type Parser struct {

internal/parser/parsers.go → parser/parsers.go

@@ -4,8 +4,8 @@ import (
 	"fmt"
 	"strconv"
 
-	"github.com/dfirebaugh/punch/internal/ast"
-	"github.com/dfirebaugh/punch/internal/token"
+	"github.com/dfirebaugh/punch/ast"
+	"github.com/dfirebaugh/punch/token"
 )
 
 func (p *Parser) ParseProgram(filename string) *ast.Program {
@@ -354,18 +354,15 @@ func (p *Parser) parseComment() {
 			p.nextToken()
 		}
 	case token.SLASH_ASTERISK:
-		// Advance past the opening token
 		p.nextToken()
 
-		// Loop until we find the closing token
 		for !(p.curTokenIs(token.ASTERISK) && p.peekTokenIs(token.SLASH)) {
 			if p.curTokenIs(token.EOF) {
 				return
 			}
 			p.nextToken()
 		}
 
-		// Advance past the closing token
 		p.nextToken()
 	default:
 		return
@@ -460,14 +457,10 @@ func (p *Parser) inferType(value ast.Expression) token.Type {
 func (p *Parser) parseForStatement() *ast.ForStatement {
 	p.trace("parsing for statement", p.curToken.Literal, p.peekToken.Literal)
 
-	// Create a ForStatement node in your AST
 	stmt := &ast.ForStatement{Token: p.curToken}
 
-	// Consume the "for" token so p.curToken is now what's after "for"
 	p.nextToken()
 
-	// -- Step 1: Parse the init statement --------------------------------
-	//    e.g., "i32 i = 1;"
 	stmt.Init = p.parseStatement()
 	if stmt.Init == nil {
 		p.error("expected initialization statement in for loop")
@@ -476,8 +469,6 @@ func (p *Parser) parseForStatement() *ast.ForStatement {
 
 	p.trace("current token", p.curToken.Literal)
 
-	// After parsing the init statement, we must see a semicolon.
-	// For example, "i32 i = 1;" must end with ';'
 	if !p.curTokenIs(token.SEMICOLON) {
 		p.error("expected ';' after for-init statement")
 		return nil
@@ -486,10 +477,6 @@ func (p *Parser) parseForStatement() *ast.ForStatement {
 	p.nextToken()
 
 	p.trace("current token", p.curToken.Literal)
-	// -- Step 2: Parse the condition -------------------------------------
-	//    e.g., "i <= n;"
-	// Condition can be empty in Go-like syntax, but your grammar might require it.
-	// We'll parse an expression if we don't see another semicolon right away.
 	if !p.curTokenIs(token.SEMICOLON) {
 		stmt.Condition = p.parseExpression(LOWEST)
 		if stmt.Condition == nil {
@@ -506,20 +493,15 @@ func (p *Parser) parseForStatement() *ast.ForStatement {
 	// consume the second ';'
 	p.nextToken()
 
-	// -- Step 3: Parse the post statement --------------------------------
-	//    e.g., "i = i + 1"
-	// This can also be empty in many “Go-like” syntaxes, but typically you have something.
 	if !p.curTokenIs(token.LBRACE) {
 		stmt.Post = p.parseStatement()
 	}
 
-	// -- Step 4: Finally, we expect '{' to parse the for-block -----------
 	if !p.curTokenIs(token.LBRACE) {
 		p.error("expected '{' after for loop post statement")
 		return nil
 	}
 
-	// parseBlockStatement parses everything in { ... } until matching '}'
 	stmt.Body = p.parseBlockStatement()
 
 	if !p.curTokenIs(token.LBRACE) {

internal/parser/precedence.go → parser/precedence.go

@@ -1,6 +1,6 @@
 package parser
 
-import "github.com/dfirebaugh/punch/internal/token"
+import "github.com/dfirebaugh/punch/token"
 
 // precedence order
 const (

internal/parser/struct.go → parser/struct.go

@@ -3,8 +3,8 @@ package parser
 import (
 	"fmt"
 
-	"github.com/dfirebaugh/punch/internal/ast"
-	"github.com/dfirebaugh/punch/internal/token"
+	"github.com/dfirebaugh/punch/ast"
+	"github.com/dfirebaugh/punch/token"
 )
 
 func (p *Parser) parseStructDefinition() *ast.StructDefinition {
@@ -134,24 +134,24 @@ func (p *Parser) parseStructLiteral() ast.Expression {
 }
 
 func (p *Parser) parseStructFieldAccess(left ast.Expression) ast.Expression {
-    p.nextToken() // consume the dot
+	p.nextToken() // consume the dot
 
-    if !p.expectPeek(token.IDENTIFIER) {
-        p.error("expected identifier after dot operator")
-        return nil
-    }
+	if !p.expectPeek(token.IDENTIFIER) {
+		p.error("expected identifier after dot operator")
+		return nil
+	}
 
-    fieldAccess := &ast.StructFieldAccess{
-        Token: p.curToken, // the dot
-        Left:  left,
-        Field: &ast.Identifier{Token: p.peekToken, Value: p.peekToken.Literal},
-    }
+	fieldAccess := &ast.StructFieldAccess{
+		Token: p.curToken, // the dot
+		Left:  left,
+		Field: &ast.Identifier{Token: p.peekToken, Value: p.peekToken.Literal},
+	}
 
-    p.nextToken() // consume the field identifier
+	p.nextToken() // consume the field identifier
 
-    if p.peekTokenIs(token.DOT) {
-        return p.parseStructFieldAccess(fieldAccess)
-    }
+	if p.peekTokenIs(token.DOT) {
+		return p.parseStructFieldAccess(fieldAccess)
+	}
 
-    return fieldAccess
+	return fieldAccess
 }

internal/repl/repl.go → repl/repl.go

@@ -5,9 +5,9 @@ import (
 	"io"
 	"strings"
 
-	"github.com/dfirebaugh/punch/internal/emitters/wat"
-	"github.com/dfirebaugh/punch/internal/lexer"
-	"github.com/dfirebaugh/punch/internal/parser"
+	"github.com/dfirebaugh/punch/emitters/wat"
+	"github.com/dfirebaugh/punch/lexer"
+	"github.com/dfirebaugh/punch/parser"
 
 	"github.com/chzyer/readline"
 )

tools/ast_explorer/main.go

@@ -6,11 +6,11 @@ import (
 	"net/http"
 	"os"
 
-	"github.com/dfirebaugh/punch/internal/emitters/js"
-	"github.com/dfirebaugh/punch/internal/emitters/wat"
-	"github.com/dfirebaugh/punch/internal/lexer"
-	"github.com/dfirebaugh/punch/internal/parser"
-	"github.com/dfirebaugh/punch/internal/token"
+	"github.com/dfirebaugh/punch/emitters/js"
+	"github.com/dfirebaugh/punch/emitters/wat"
+	"github.com/dfirebaugh/punch/lexer"
+	"github.com/dfirebaugh/punch/parser"
+	"github.com/dfirebaugh/punch/token"
 )
 
 func parseHandler(w http.ResponseWriter, r *http.Request) {

tools/punchgen/main.go

@@ -5,11 +5,11 @@ import (
 	"fmt"
 	"syscall/js"
 
-	js_gen "github.com/dfirebaugh/punch/internal/emitters/js"
-	"github.com/dfirebaugh/punch/internal/emitters/wat"
-	"github.com/dfirebaugh/punch/internal/lexer"
-	"github.com/dfirebaugh/punch/internal/parser"
-	"github.com/dfirebaugh/punch/internal/token"
+	js_gen "github.com/dfirebaugh/punch/emitters/js"
+	"github.com/dfirebaugh/punch/emitters/wat"
+	"github.com/dfirebaugh/punch/lexer"
+	"github.com/dfirebaugh/punch/parser"
+	"github.com/dfirebaugh/punch/token"
 )
 
 func parse(this js.Value, p []js.Value) interface{} {