declarations.
R=rsc
APPROVED=rsc
DELTA=587 (519 added, 21 deleted, 47 changed)
OCL=32754
CL=32788
func (a *compiler) checkAssign(pos token.Position, rs []*exprCompiler, errOp, errPosName string) (*assignCompiler, bool)
func (a *compiler) compileAssign(pos token.Position, lt Type, rs []*exprCompiler, errOp, errPosName string) (func(lv Value, f *Frame))
func (a *compiler) compileType(b *block, typ ast.Expr) Type
+func (a *compiler) compileTypeDecl(b *block, decl *ast.GenDecl) bool
func (a *compiler) compileFuncType(b *block, typ *ast.FuncType) *FuncDecl
func (a *compiler) compileArrayLen(b *block, expr ast.Expr) (int64, bool)
// same named type. If conv if true, this is conversion
// compatibility, where two named types are conversion
// compatible if their definitions are conversion compatible.
+ //
+ // TODO(austin) Deal with recursive types
compat(o Type, conv bool) bool;
// lit returns this type's literal. If this is a named type,
// this is the unnamed underlying type. Otherwise, this is an
Elem(i int64) Value;
}
+type StructValue interface {
+ Value;
+ // TODO(austin) This is another useless Get()
+ Get() StructValue;
+ Field(i int) Value;
+}
+
type PtrValue interface {
Value;
Get() Value;
evalIdealFloat func() *bignum.Rational;
evalString func(f *Frame) string;
evalArray func(f *Frame) ArrayValue;
+ evalStruct func(f *Frame) StructValue;
evalPtr func(f *Frame) Value;
evalFunc func(f *Frame) Func;
evalMulti func(f *Frame) []Value;
func (a *exprCompiler) genIdentOp(level int, index int)
func (a *exprCompiler) genIndexArray(l *exprCompiler, r *exprCompiler)
func (a *exprCompiler) genFuncCall(call func(f *Frame) []Value)
-func (a *exprCompiler) genStarOp(v *exprCompiler)
+func (a *exprCompiler) genValue(vf func(*Frame) Value)
func (a *exprCompiler) genUnaryOpNeg(v *exprCompiler)
func (a *exprCompiler) genUnaryOpNot(v *exprCompiler)
func (a *exprCompiler) genUnaryOpXor(v *exprCompiler)
return a.evalArray;
}
+func (a *exprCompiler) asStruct() (func(f *Frame) StructValue) {
+ if a.evalStruct == nil {
+ log.Crashf("tried to get %v node as StructType", a.t);
+ }
+ return a.evalStruct;
+}
+
func (a *exprCompiler) asPtr() (func(f *Frame) Value) {
if a.evalPtr == nil {
log.Crashf("tried to get %v node as PtrType", a.t);
return res;
}
+func (a *exprCompiler) genStarOp(v *exprCompiler) {
+ a.genValue(v.asPtr());
+}
+
/*
* Assignments
*/
}
func (a *exprCompiler) DoSelectorExpr(x *ast.SelectorExpr) {
- log.Crash("Not implemented");
+ v := a.copyVisit(x.X);
+ if v.t == nil {
+ return;
+ }
+
+ // mark marks a field that matches the selector name. It
+ // tracks the best depth found so far and whether more than
+ // one field has been found at that depth.
+ bestDepth := -1;
+ ambig := false;
+ amberr := "";
+ mark := func(depth int, pathName string) {
+ switch {
+ case bestDepth == -1 || depth < bestDepth:
+ bestDepth = depth;
+ ambig = false;
+ amberr = "";
+
+ case depth == bestDepth:
+ ambig = true;
+
+ default:
+ log.Crashf("Marked field at depth %d, but already found one at depth %d", depth, bestDepth);
+ }
+ amberr += "\n\t" + pathName[1:len(pathName)];
+ };
+
+ name := x.Sel.Value;
+ visited := make(map[Type] bool);
+
+ // find recursively searches for the named field, starting at
+ // type t. If it finds the named field, it returns a function
+ // which takes an exprCompiler that retrieves a value of type
+ // 't' and fills 'a' to retrieve the named field. We delay
+ // exprCompiler construction to avoid filling in anything
+ // until we're sure we have the right field, and to avoid
+ // producing lots of garbage exprCompilers as we search.
+ var find func(Type, int, string) (func (*exprCompiler));
+ find = func(t Type, depth int, pathName string) (func (*exprCompiler)) {
+ // Don't bother looking if we've found something shallower
+ if bestDepth != -1 && bestDepth < depth {
+ return nil;
+ }
+
+ // Don't check the same type twice and avoid loops
+ if _, ok := visited[t]; ok {
+ return nil;
+ }
+ visited[t] = true;
+
+ // Implicit dereference
+ deref := false;
+ if ti, ok := t.(*PtrType); ok {
+ deref = true;
+ t = ti.Elem;
+ }
+
+ // If it's a named type, look for methods
+ if ti, ok := t.(*NamedType); ok {
+ method, ok := ti.methods[name];
+ if ok {
+ mark(depth, pathName + "." + name);
+ log.Crash("Methods not implemented");
+ }
+ t = ti.def;
+ }
+
+ // If it's a struct type, check fields and embedded types
+ var builder func(*exprCompiler);
+ if t, ok := t.(*StructType); ok {
+ for i, f := range t.Elems {
+ var this *exprCompiler;
+ var sub func(*exprCompiler);
+ switch {
+ case f.Name == name:
+ mark(depth, pathName + "." + name);
+ this = a;
+ sub = func(*exprCompiler) {};
+
+ case f.Anonymous:
+ sub = find(f.Type, depth+1, pathName + "." + f.Name);
+ if sub == nil {
+ continue;
+ }
+ this = a.copy();
+
+ default:
+ continue;
+ }
+
+ // We found something. Create a
+ // builder for accessing this field.
+ ft := f.Type;
+ index := i;
+ builder = func(parent *exprCompiler) {
+ this.t = ft;
+ var evalAddr func(f *Frame) Value;
+ if deref {
+ pf := parent.asPtr();
+ evalAddr = func(f *Frame) Value {
+ return pf(f).(StructValue).Field(index);
+ };
+ } else {
+ pf := parent.asStruct();
+ evalAddr = func(f *Frame) Value {
+ return pf(f).Field(index);
+ };
+ }
+ this.genValue(evalAddr);
+ sub(this);
+ };
+ }
+ }
+
+ return builder;
+ };
+
+ builder := find(v.t, 0, "");
+ if builder == nil {
+ a.diag("type %v has no field or method %s", v.t, name);
+ return;
+ }
+ if ambig {
+ a.diag("field %s is ambiguous in type %v%s", name, v.t, amberr);
+ return;
+ }
+
+ a.desc = "selector expression";
+ builder(v);
}
func (a *exprCompiler) DoIndexExpr(x *ast.IndexExpr) {
switch vt := v.t.lit().(type) {
case *PtrType:
a.t = vt.Elem;
+ // TODO(austin) Deal with nil pointers
a.genStarOp(v);
a.desc = "indirect expression";
return;
}
// Arrays and structs may not be compared to anything.
+ // TODO(austin) Use a multi-type switch
if _, ok := l.t.(*ArrayType); ok {
a.diagOpTypes(op, origlt, origrt);
return;
}
+ if _, ok := l.t.(*StructType); ok {
+ a.diagOpTypes(op, origlt, origrt);
+ return;
+ }
a.t = BoolType;
default:
if lenExpr == nil {
return 0, false;
}
- if !lenExpr.t.isInteger() {
- a.diagAt(expr, "array size must be an integer");
- return 0, false;
- }
+ // XXX(Spec) Are ideal floats with no fractional part okay?
if lenExpr.t.isIdeal() {
lenExpr = lenExpr.convertTo(IntType);
if lenExpr == nil {
}
}
+ if !lenExpr.t.isInteger() {
+ a.diagAt(expr, "array size must be an integer");
+ return 0, false;
+ }
+
switch _ := lenExpr.t.lit().(type) {
case *intType:
return lenExpr.evalInt(nil), true;
case *ArrayType:
val := v.(ArrayValue).Get();
a.evalArray = func(f *Frame) ArrayValue { return val };
+ case *StructType:
+ val := v.(StructValue).Get();
+ a.evalStruct = func(f *Frame) StructValue { return val };
case *PtrType:
val := v.(PtrValue).Get();
a.evalPtr = func(f *Frame) Value { return val };
a.evalString = func(f *Frame) string { return f.Get(level, index).(StringValue).Get() };
case *ArrayType:
a.evalArray = func(f *Frame) ArrayValue { return f.Get(level, index).(ArrayValue).Get() };
+ case *StructType:
+ a.evalStruct = func(f *Frame) StructValue { return f.Get(level, index).(StructValue).Get() };
case *PtrType:
a.evalPtr = func(f *Frame) Value { return f.Get(level, index).(PtrValue).Get() };
case *FuncType:
a.evalString = func(f *Frame) string { return lf(f).Elem(rf(f)).(StringValue).Get() };
case *ArrayType:
a.evalArray = func(f *Frame) ArrayValue { return lf(f).Elem(rf(f)).(ArrayValue).Get() };
+ case *StructType:
+ a.evalStruct = func(f *Frame) StructValue { return lf(f).Elem(rf(f)).(StructValue).Get() };
case *PtrType:
a.evalPtr = func(f *Frame) Value { return lf(f).Elem(rf(f)).(PtrValue).Get() };
case *FuncType:
a.evalString = func(f *Frame) string { return call(f)[0].(StringValue).Get() };
case *ArrayType:
a.evalArray = func(f *Frame) ArrayValue { return call(f)[0].(ArrayValue).Get() };
+ case *StructType:
+ a.evalStruct = func(f *Frame) StructValue { return call(f)[0].(StructValue).Get() };
case *PtrType:
a.evalPtr = func(f *Frame) Value { return call(f)[0].(PtrValue).Get() };
case *FuncType:
}
}
-func (a *exprCompiler) genStarOp(v *exprCompiler) {
- vf := v.asPtr();
- a.evalAddr = func(f *Frame) Value { return vf(f) };
+func (a *exprCompiler) genValue(vf func(*Frame) Value) {
+ a.evalAddr = vf;
switch _ := a.t.lit().(type) {
case *boolType:
a.evalBool = func(f *Frame) bool { return vf(f).(BoolValue).Get() };
a.evalString = func(f *Frame) string { return vf(f).(StringValue).Get() };
case *ArrayType:
a.evalArray = func(f *Frame) ArrayValue { return vf(f).(ArrayValue).Get() };
+ case *StructType:
+ a.evalStruct = func(f *Frame) StructValue { return vf(f).(StructValue).Get() };
case *PtrType:
a.evalPtr = func(f *Frame) Value { return vf(f).(PtrValue).Get() };
case *FuncType:
}
// We take the representative type of t because multiple
// levels of naming are useless.
- nt := &NamedType{pos, name, t.lit()};
+ if t != nil {
+ t = t.lit();
+ }
+ nt := &NamedType{pos, name, t, false, make(map[string] Method)};
b.defs[name] = nt;
return nt;
}
}
func (a *stmtCompiler) DoDeclStmt(s *ast.DeclStmt) {
+ ok := true;
+
switch decl := s.Decl.(type) {
case *ast.BadDecl:
// Do nothing. Already reported by parser.
- return;
+ ok = false;
case *ast.FuncDecl:
log.Crash("FuncDecl at statement level");
case token.IMPORT:
log.Crash("import at statement level");
- case token.CONST, token.TYPE:
+ case token.CONST:
log.Crashf("%v not implemented", decl.Tok);
+ case token.TYPE:
+ ok = a.compileTypeDecl(a.block, decl);
+
case token.VAR:
- ok := true;
for _, spec := range decl.Specs {
spec := spec.(*ast.ValueSpec);
if spec.Values == nil {
// Declaration without assignment
- var t Type;
if spec.Type == nil {
// Parser should have caught
log.Crash("Type and Values nil");
}
- t = a.compileType(a.block, spec.Type);
+ t := a.compileType(a.block, spec.Type);
if t == nil {
// Define placeholders
ok = false;
lhs[i] = n;
}
a.doAssign(lhs, spec.Values, decl.Tok, spec.Type);
+ // TODO(austin) This is rediculous. doAssign
+ // indicates failure by setting a.err.
+ if a.err {
+ ok = false;
+ }
}
}
- if ok {
- a.err = false;
- }
}
default:
log.Crashf("Unexpected Decl type %T", s.Decl);
}
+
+ if ok {
+ a.err = false;
+ }
}
func (a *stmtCompiler) DoEmptyStmt(s *ast.EmptyStmt) {
func (t *ArrayType) Zero() Value
+/*
+ * Struct
+ */
+
+type StructField struct {
+ Name string;
+ Type Type;
+ Anonymous bool;
+}
+
+type StructType struct {
+ commonType;
+ Elems []StructField;
+ maxDepth int;
+}
+
+var structTypes = newTypeArrayMap()
+
+// Two struct types are identical if they have the same sequence of
+// fields, and if corresponding fields have the same names and
+// identical types. Two anonymous fields are considered to have the
+// same name.
+
+func NewStructType(fields []StructField) *StructType {
+ // Start by looking up just the types
+ fts := make([]Type, len(fields));
+ for i, f := range fields {
+ fts[i] = f.Type;
+ }
+ tMapI := structTypes.Get(fts);
+ if tMapI == nil {
+ tMapI = structTypes.Put(fts, make(map[string] *StructType));
+ }
+ tMap := tMapI.(map[string] *StructType);
+
+ // Construct key for field names
+ key := "";
+ for _, f := range fields {
+ // XXX(Spec) It's not clear if struct { T } and struct
+ // { T T } are either identical or compatible. The
+ // "Struct Types" section says that the name of that
+ // field is "T", which suggests that they are
+ // identical, but it really means that it's the name
+ // for the purpose of selector expressions and nothing
+ // else. We decided that they should be neither
+ // identical or compatible.
+ if f.Anonymous {
+ key += "!";
+ }
+ key += f.Name + " ";
+ }
+
+ // XXX(Spec) Do the tags also have to be identical for the
+ // types to be identical? I certainly hope so, because
+ // otherwise, this is the only case where two distinct type
+ // objects can represent identical types.
+
+ t, ok := tMap[key];
+ if !ok {
+ // Create new struct type
+
+ // Compute max anonymous field depth
+ maxDepth := 1;
+ for _, f := range fields {
+ // TODO(austin) Careful of type T struct { *T }
+ if st, ok := f.Type.(*StructType); ok {
+ if st.maxDepth + 1 > maxDepth {
+ maxDepth = st.maxDepth + 1;
+ }
+ }
+ }
+
+ t = &StructType{commonType{}, fields, maxDepth};
+ tMap[key] = t;
+ }
+ return t;
+}
+
+func (t *StructType) compat(o Type, conv bool) bool {
+ t2, ok := o.lit().(*StructType);
+ if !ok {
+ return false;
+ }
+ if len(t.Elems) != len(t2.Elems) {
+ return false;
+ }
+ for i, e := range t.Elems {
+ e2 := t2.Elems[i];
+ // XXX(Spec) An anonymous and a non-anonymous field
+ // are neither identical nor compatible.
+ if (e.Anonymous != e2.Anonymous ||
+ (!e.Anonymous && e.Name != e2.Name) ||
+ !e.Type.compat(e2.Type, conv)) {
+ return false;
+ }
+ }
+ return true;
+}
+
+func (t *StructType) lit() Type {
+ return t;
+}
+
+func (t *StructType) String() string {
+ s := "struct {";
+ for i, f := range t.Elems {
+ if i > 0 {
+ s += "; ";
+ }
+ if !f.Anonymous {
+ s += f.Name + " ";
+ }
+ s += f.Type.String();
+ }
+ return s + "}";
+}
+
+func (t *StructType) Zero() Value
+
/*
* Pointer
*/
* Named types
*/
+type Method struct {
+ decl *FuncDecl;
+ fn Func;
+}
+
type NamedType struct {
token.Position;
name string;
- // Underlying type
+ // Underlying type. If incomplete is true, this will be nil.
+ // If incomplete is false and this is still nil, then this is
+ // a placeholder type representing an error.
def Type;
- // TODO(austin) Methods can be on NamedType or *NamedType
- //methods map[string] XXX;
+ // True while this type is being defined.
+ incomplete bool;
+ methods map[string] Method;
}
func (t *NamedType) compat(o Type, conv bool) bool {
import (
"eval";
"go/ast";
+ "go/token";
"log";
)
type typeCompiler struct {
*compiler;
block *block;
+ // Check to be performed after a type declaration is compiled.
+ //
+ // TODO(austin) This will probably have to change after we
+ // eliminate forward declarations.
+ lateCheck func() bool
}
-func (a *typeCompiler) compileType(x ast.Expr) Type
+func (a *typeCompiler) compileType(x ast.Expr, allowRec bool) Type
-func (a *typeCompiler) compileIdent(x *ast.Ident) Type {
+func (a *typeCompiler) compileIdent(x *ast.Ident, allowRec bool) Type {
_, def := a.block.Lookup(x.Value);
if def == nil {
a.diagAt(x, "%s: undefined", x.Value);
case *Variable:
a.diagAt(x, "variable %v used as type", x.Value);
return nil;
+ case *NamedType:
+ if !allowRec && def.incomplete {
+ a.diagAt(x, "illegal recursive type");
+ return nil;
+ }
+ if !def.incomplete && def.def == nil {
+ // Placeholder type from an earlier error
+ return nil;
+ }
+ return def;
case Type:
return def;
}
return nil;
}
-func (a *typeCompiler) compileArrayType(x *ast.ArrayType) *ArrayType {
+func (a *typeCompiler) compileArrayType(x *ast.ArrayType, allowRec bool) Type {
// Compile length expression
if x.Len == nil {
a.diagAt(x, "slice types not implemented");
l, ok := a.compileArrayLen(a.block, x.Len);
// Compile element type
- elem := a.compileType(x.Elt);
+ elem := a.compileType(x.Elt, allowRec);
if !ok {
return nil;
return NewArrayType(l, elem);
}
-func (a *typeCompiler) compilePtrType(x *ast.StarExpr) *PtrType {
- elem := a.compileType(x.X);
- if elem == nil {
- return nil;
- }
- return NewPtrType(elem);
-}
-
func countFields(fs []*ast.Field) int {
n := 0;
for _, f := range fs {
return n;
}
-func (a *typeCompiler) compileFields(fs []*ast.Field) ([]Type, []*ast.Ident) {
+func (a *typeCompiler) compileFields(fs []*ast.Field, allowRec bool) ([]Type, []*ast.Ident, []token.Position, bool) {
n := countFields(fs);
ts := make([]Type, n);
ns := make([]*ast.Ident, n);
+ ps := make([]token.Position, n);
bad := false;
i := 0;
for fi, f := range fs {
- t := a.compileType(f.Type);
+ t := a.compileType(f.Type, allowRec);
if t == nil {
bad = true;
}
if f.Names == nil {
- // TODO(austin) In a struct, this has an
- // implicit name. However, this also triggers
- // for function return values, which should
- // not be given names.
ns[i] = nil;
ts[i] = t;
+ ps[i] = f.Type.Pos();
i++;
continue;
}
for _, n := range f.Names {
ns[i] = n;
ts[i] = t;
+ ps[i] = n.Pos();
i++;
}
}
+ return ts, ns, ps, bad;
+}
+
+func (a *typeCompiler) compileStructType(x *ast.StructType, allowRec bool) Type {
+ ts, names, poss, bad := a.compileFields(x.Fields, allowRec);
+
+ // XXX(Spec) The spec claims that field identifiers must be
+ // unique, but 6g only checks this when they are accessed. I
+ // think the spec is better in this regard: if I write two
+ // fields with the same name in the same struct type, clearly
+ // that's a mistake. This definition does *not* descend into
+ // anonymous fields, so it doesn't matter if those change.
+ // There's separate language in the spec about checking
+ // uniqueness of field names inherited from anonymous fields
+ // at use time.
+ fields := make([]StructField, len(ts));
+ nameSet := make(map[string] token.Position, len(ts));
+ for i := range fields {
+ // Compute field name and check anonymous fields
+ var name string;
+ if names[i] != nil {
+ name = names[i].Value;
+ } else {
+ if ts[i] == nil {
+ continue;
+ }
+
+ var nt *NamedType;
+ // [For anonymous fields,] the unqualified
+ // type name acts as the field identifier.
+ switch t := ts[i].(type) {
+ case *NamedType:
+ name = t.name;
+ nt = t;
+ case *PtrType:
+ switch t := t.Elem.(type) {
+ case *NamedType:
+ name = t.name;
+ nt = t;
+ }
+ }
+ // [An anonymous field] must be specified as a
+ // type name T or as a pointer to a type name
+ // *T, and T itself, may not be a pointer or
+ // interface type.
+ if nt == nil {
+ a.diagAt(&poss[i], "embedded type must T or *T, where T is a named type");
+ bad = true;
+ continue;
+ }
+ // The check for embedded pointer types must
+ // be deferred because of things like
+ // type T *struct { T }
+ lateCheck := a.lateCheck;
+ a.lateCheck = func() bool {
+ if _, ok := nt.lit().(*PtrType); ok {
+ a.diagAt(&poss[i], "embedded type %v is a pointer type", nt);
+ return false;
+ }
+ return lateCheck();
+ };
+ }
+
+ // Check name uniqueness
+ if prev, ok := nameSet[name]; ok {
+ a.diagAt(&poss[i], "field %s redeclared\n\tprevious declaration at %s", name, &prev);
+ bad = true;
+ continue;
+ }
+ nameSet[name] = poss[i];
+
+ // Create field
+ fields[i].Name = name;
+ fields[i].Type = ts[i];
+ fields[i].Anonymous = (names[i] == nil);
+ }
+
if bad {
- return nil, nil;
+ return nil;
}
- return ts, ns;
+
+ return NewStructType(fields);
}
-func (a *typeCompiler) compileFuncType(x *ast.FuncType) *FuncDecl {
- // TODO(austin) Variadic function types
+func (a *typeCompiler) compilePtrType(x *ast.StarExpr) Type {
+ elem := a.compileType(x.X, true);
+ if elem == nil {
+ return nil;
+ }
+ return NewPtrType(elem);
+}
- bad := false;
+func (a *typeCompiler) compileFuncType(x *ast.FuncType, allowRec bool) *FuncDecl {
+ // TODO(austin) Variadic function types
- in, inNames := a.compileFields(x.Params);
- out, outNames := a.compileFields(x.Results);
+ // The types of parameters and results must be complete.
+ //
+ // TODO(austin) It's not clear they actually have to be complete.
+ in, inNames, _, inBad := a.compileFields(x.Params, allowRec);
+ out, outNames, _, outBad := a.compileFields(x.Results, allowRec);
- if in == nil || out == nil {
+ if inBad || outBad {
return nil;
}
return &FuncDecl{NewFuncType(in, false, out), nil, inNames, outNames};
}
-func (a *typeCompiler) compileType(x ast.Expr) Type {
+func (a *typeCompiler) compileType(x ast.Expr, allowRec bool) Type {
switch x := x.(type) {
+ case *ast.BadExpr:
+ return nil;
+
case *ast.Ident:
- return a.compileIdent(x);
+ return a.compileIdent(x, allowRec);
case *ast.ArrayType:
- return a.compileArrayType(x);
+ return a.compileArrayType(x, allowRec);
case *ast.StructType:
- goto notimpl;
+ return a.compileStructType(x, allowRec);
case *ast.StarExpr:
return a.compilePtrType(x);
case *ast.FuncType:
- return a.compileFuncType(x).Type;
+ fd := a.compileFuncType(x, allowRec);
+ if fd == nil {
+ return nil;
+ }
+ return fd.Type;
case *ast.InterfaceType:
goto notimpl;
goto notimpl;
case *ast.ParenExpr:
- return a.compileType(x.X);
+ return a.compileType(x.X, allowRec);
case *ast.Ellipsis:
a.diagAt(x, "illegal use of ellipsis");
* Type compiler interface
*/
+func noLateCheck() bool {
+ return true;
+}
+
func (a *compiler) compileType(b *block, typ ast.Expr) Type {
- tc := &typeCompiler{a, b};
- return tc.compileType(typ);
+ tc := &typeCompiler{a, b, noLateCheck};
+ t := tc.compileType(typ, false);
+ if !tc.lateCheck() {
+ t = nil;
+ }
+ return t;
+}
+
+func (a *compiler) compileTypeDecl(b *block, decl *ast.GenDecl) bool {
+ ok := true;
+ for _, spec := range decl.Specs {
+ spec := spec.(*ast.TypeSpec);
+ // Create incomplete type for this type
+ nt := b.DefineType(spec.Name.Value, spec.Name.Pos(), nil);
+ if nt != nil {
+ nt.(*NamedType).incomplete = true;
+ }
+ // Compile type
+ tc := &typeCompiler{a, b, noLateCheck};
+ t := tc.compileType(spec.Type, false);
+ if t == nil {
+ // Create a placeholder type
+ ok = false;
+ }
+ // Fill incomplete type
+ if nt != nil {
+ nt.(*NamedType).def = t;
+ nt.(*NamedType).incomplete = false;
+ }
+ // Perform late type checking with complete type
+ if !tc.lateCheck() {
+ ok = false;
+ if nt != nil {
+ // Make the type a placeholder
+ nt.(*NamedType).def = nil;
+ }
+ }
+ }
+ return ok;
}
func (a *compiler) compileFuncType(b *block, typ *ast.FuncType) *FuncDecl {
- tc := &typeCompiler{a, b};
- return tc.compileFuncType(typ);
+ tc := &typeCompiler{a, b, noLateCheck};
+ res := tc.compileFuncType(typ, false);
+ if res != nil {
+ if !tc.lateCheck() {
+ res = nil;
+ }
+ }
+ return res;
}
return &res;
}
+/*
+ * Struct
+ */
+
+type structV []Value
+
+// TODO(austin) Should these methods (and arrayV's) be on structV
+// instead of *structV?
+func (v *structV) String() string {
+ res := "{";
+ for i, v := range *v {
+ if i > 0 {
+ res += "; ";
+ }
+ res += v.String();
+ }
+ return res + "}";
+}
+
+func (v *structV) Assign(o Value) {
+ oa := o.(StructValue);
+ l := len(*v);
+ for i := 0; i < l; i++ {
+ (*v)[i].Assign(oa.Field(i));
+ }
+}
+
+func (v *structV) Get() StructValue {
+ return v;
+}
+
+func (v *structV) Field(i int) Value {
+ return (*v)[i];
+}
+
+func (t *StructType) Zero() Value {
+ res := structV(make([]Value, len(t.Elems)));
+ for i, f := range t.Elems {
+ res[i] = f.Type.Zero();
+ }
+ return &res;
+}
+
/*
* Pointer
*/
func (t *MultiType) Zero() Value {
res := make([]Value, len(t.Elems));
- for i := 0; i < len(t.Elems); i++ {
- res[i] = t.Elems[i].Zero();
+ for i, t := range t.Elems {
+ res[i] = t.Zero();
}
return multiV(res);
}