Introduce explicit "var x T" syntax.

This makes type checking easier and more explicit.
This commit is contained in:
Nigel Tao committed 2017-05-07 09:00:36 +10:00
1 parent 4615d0d670
commit 56de3228e1
6 files changed
+95 -28

No files matched your search

+10 -3
View File
@@ -50,15 +50,21 @@ const (
// - RHS: <KExpr>
KAssert
// KAssign is "LHS = RHS" or "LHS op= RHS:
// KAssign is "LHS = RHS" or "LHS op= RHS":
// - ID0: operator
// - LHS: <KExpr>
// - RHS: <KExpr>
KAssign
// KVar is "var ID1 LHS" or "var ID1 LHS = RHS":
// - ID1: name
// - LHS: <KType>
// - RHS: <nil|KExpr>
KVar
// KParam is a "name type" parameter:
// - ID0: name
// - RHS: <KType>
// - ID1: name
// - LHS: <KType>
KParam
// KFor is "for { List2 }" or "for LHS { List2 }":
@@ -149,6 +155,7 @@ var kindStrings = [...]string{
KStruct: "KStruct",
KType: "KType",
KUse: "KUse",
KVar: "KVar",
}
type Flags uint32
+51 -18
View File
@@ -135,12 +135,26 @@ func (c *Checker) checkFuncBody(n *a.Node) error {
return nil
}
p := TypeMap{}
for _, m := range n.List2 {
if err := c.checkVars(m, p); err != nil {
return fmt.Errorf("%v at %s:%d", err, m.Filename, m.Line)
}
}
for _, m := range n.List2 {
if err := c.checkStatement(m, p); err != nil {
return fmt.Errorf("%v at %s:%d", err, m.Filename, m.Line)
}
}
qid := t.QID{n.ID0, n.ID1}
if _, ok := c.funcs[qid]; ok {
if qid[0] == 0 {
return fmt.Errorf(`check: duplicate function "%s"`, c.idMap.ByID(qid[1]))
} else {
return fmt.Errorf(`check: duplicate function "%s.%s"`, c.idMap.ByID(qid[0]), c.idMap.ByID(qid[1]))
}
}
c.funcs[qid] = Func{
QID: qid,
Node: n,
@@ -149,6 +163,33 @@ func (c *Checker) checkFuncBody(n *a.Node) error {
return nil
}
func (c *Checker) checkVars(n *a.Node, p TypeMap) error {
if n == nil {
return nil
}
if n.Kind == a.KVar {
if _, ok := p[n.ID1]; ok {
return fmt.Errorf("check: duplicate var %q", c.idMap.ByID(n.ID1))
}
if err := c.checkType(n.LHS); err != nil {
return err
}
if n.RHS != nil {
// TODO: check that n.RHS doesn't mention the variable itself.
}
p[n.ID1] = n.LHS
return nil
}
for _, l := range [...][]*a.Node{n.List0, n.List1, n.List2} {
for _, m := range l {
if err := c.checkVars(m, p); err != nil {
return err
}
}
}
return nil
}
func (c *Checker) checkStatement(n *a.Node, p TypeMap) error {
if n == nil {
return nil
@@ -164,23 +205,22 @@ func (c *Checker) checkStatement(n *a.Node, p TypeMap) error {
return nil
case a.KAssign:
if err := c.checkExpr(n.LHS); err != nil {
return err
}
if err := c.checkExpr(n.RHS); err != nil {
return err
}
// TODO: check that n.RHS.Type is assignable to n.LHS.Type.
// TODO, look at the op (n.ID0).
if id := isUserDefinedIdent(n.LHS); id != 0 {
if previouslyInferredType, ok := p[id]; ok {
// TODO: check that n.RHS.Type is assignable to previouslyInferredType.
n.LHS.Type = previouslyInferredType
} else {
p[id] = n.RHS.Type
n.LHS.Type = n.RHS.Type
}
} else {
if err := c.checkExpr(n.LHS); err != nil {
return nil
case a.KVar:
if n.RHS != nil {
if err := c.checkExpr(n.RHS); err != nil {
return err
}
// TODO: check that n.RHS.Type is assignable to n.LHS.Type.
// TODO: check that n.RHS.Type is assignable to n.LHS.
}
return nil
@@ -379,10 +419,3 @@ var numTypeRanges = [256][2]*big.Int{
}
var zero = big.NewInt(0)
func isUserDefinedIdent(n *a.Node) t.ID {
if n != nil && n.Kind == a.KExpr && n.ID0 == 0 && n.ID1.IsIdent() && !n.ID1.IsBuiltIn() {
return n.ID1
}
return 0
}
+2 -2
View File
@@ -17,8 +17,8 @@ func TestCheck(t *testing.T) {
const filename = "foo.puffs"
const src = `
func bar()() {
x = 1 as u8
y = 2 as i32
var x u8
var y i32 = 2
}
`
+28 -3
View File
@@ -228,14 +228,14 @@ func (p *parser) parseParam() (*a.Node, error) {
if err != nil {
return nil, err
}
rhs, err := p.parseType()
lhs, err := p.parseType()
if err != nil {
return nil, err
}
return &a.Node{
Kind: a.KParam,
ID0: id,
RHS: rhs,
ID1: id,
LHS: lhs,
}, nil
}
@@ -451,6 +451,31 @@ func (p *parser) parseStatement1() (*a.Node, error) {
Kind: a.KReturn,
LHS: lhs,
}, nil
case t.IDVar:
p.src = p.src[1:]
id, err := p.parseIdent()
if err != nil {
return nil, err
}
lhs, err := p.parseType()
if err != nil {
return nil, err
}
rhs := (*a.Node)(nil)
if p.peekID() == t.IDEq {
p.src = p.src[1:]
rhs, err = p.parseExpr()
if err != nil {
return nil, err
}
}
return &a.Node{
Kind: a.KVar,
ID1: id,
LHS: lhs,
RHS: rhs,
}, nil
}
lhs, err := p.parseExpr()
+2
View File
@@ -178,6 +178,7 @@ const (
IDContinue = ID(0x68<<KeyShift | FlagsOther | FlagsImplicitSemicolon)
IDStruct = ID(0x69<<KeyShift | FlagsOther)
IDUse = ID(0x6A<<KeyShift | FlagsOther)
IDVar = ID(0x6B<<KeyShift | FlagsOther)
IDFalse = ID(0x90<<KeyShift | FlagsLiteral | FlagsImplicitSemicolon)
IDTrue = ID(0x91<<KeyShift | FlagsLiteral | FlagsImplicitSemicolon)
@@ -301,6 +302,7 @@ var builtInsByKey = [nBuiltInKeys]struct {
IDContinue >> KeyShift: {"continue", IDContinue},
IDStruct >> KeyShift: {"struct", IDStruct},
IDUse >> KeyShift: {"use", IDUse},
IDVar >> KeyShift: {"var", IDVar},
IDFalse >> KeyShift: {"false", IDFalse},
IDTrue >> KeyShift: {"true", IDTrue},
+2 -2
View File
@@ -9,8 +9,8 @@ struct lzw_decoder?(
)
func lzw_decoder.decode?(dst ptr io.buf1, src ptr io.buf1, src_final bool)() {
bits = 0 as u32
nBits = 0 as u32
var bits u32
var nBits u32
// TODO: implement.
}