api/resolver/expression.go - platform/tools/gpu - Git at Google

 // Copyright (C) 2014 The Android Open Source Project
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 package resolver

 import (
 	"fmt"
 	"strconv"

 	"android.googlesource.com/platform/tools/gpu/api/ast"
 	"android.googlesource.com/platform/tools/gpu/api/semantic"
 )

 type invalid struct{}

 func (invalid) ExpressionType() semantic.Type { return semantic.VoidType }

 // expression translates the ast expression to a semantic expression.
 func expression(ctx *context, in interface{}) semantic.Expression {
 	switch in := in.(type) {
 	case *ast.UnaryOp:
 		return unaryOp(ctx, in)
 	case *ast.BinaryOp:
 		return binaryOp(ctx, in)
 	case *ast.Call:
 		return call(ctx, in)
 	case *ast.Switch:
 		return select_(ctx, in)
 	case *ast.Member:
 		return member(ctx, in)
 	case *ast.Index:
 		return index(ctx, in)
 	case *ast.Identifier:
 		return identifier(ctx, in)
 	case *ast.ClassInitializer:
 		return classInitializer(ctx, in)
 	case *ast.New:
 		return new(ctx, in)
 	case *ast.Group:
 		return expression(ctx, in.Expression)
 	case *ast.Cast:
 		return cast(ctx, in)
 	case *ast.Length:
 		return length(ctx, in)
 	case *ast.Unknown:
 		return &semantic.Unknown{AST: in}
 	case *ast.Number:
 		return number(ctx, in)
 	case *ast.Bool:
 		return semantic.BoolValue(in.Value)
 	case *ast.String:
 		return semantic.StringValue(in.Value)
 	default:
 		ctx.icef(in, "Unhandled expression type %T found", in)
 		return invalid{}
 	}
 }

 func call(ctx *context, in *ast.Call) semantic.Expression {
 	target := expression(ctx, in.Target)
 	switch target := target.(type) {
 	case *macroStub:
 		return macroCall(ctx, in, target)
 	case *semantic.Callable:
 		return functionCall(ctx, in, target)
 	default:
 		ctx.errorf(in, "Invalid method call target %T found", target)
 		return invalid{}
 	}
 }

 func callArguments(ctx *context, in []interface{}, params []*semantic.Parameter, name string) []semantic.Expression {
 	out := []semantic.Expression{}
 	if len(params) != len(in) {
 		ctx.errorf(in, "wrong number of arguments to %s, expected %v got %v", name, len(params), len(in))
 		return out
 	}
 	for i, a := range in {
 		p := params[i]
 		ctx.with(p.Type, func() {
 			arg := expression(ctx, a)
 			at := arg.ExpressionType()
 			out = append(out, arg)
 			if !assignable(p.Type, at) {
 				ctx.errorf(a, "argument %d to %s is wrong type, expected %s got %s", i, name, typename(p.Type), typename(at))
 			}
 		})
 	}
 	return out
 }

 func functionCall(ctx *context, in *ast.Call, target *semantic.Callable) *semantic.Call {
 	out := &semantic.Call{AST: in, Target: target, Type: semantic.VoidType}
 	params := target.Function.FullParameters
 	if target.Object != nil {
 		if target.Function.This == nil {
 			ctx.errorf(in, "method call on non method %s of %T", target.Function.Name, target.Object)
 			return out
 		}
 		params = params[1:len(params)]
 	}
 	if target.Function.Return.Type != semantic.VoidType {
 		params = params[0 : len(params)-1]
 	}
 	out.Arguments = callArguments(ctx, in.Arguments, params, target.Function.Name)
 	out.Type = out.Target.Function.Return.Type
 	return out
 }

 func macroCall(ctx *context, in *ast.Call, stub *macroStub) semantic.Expression {
 	if ctx.scope.block == nil {
 		ctx.errorf(in, "macro call outside of block scope")
 		return invalid{}
 	}
 	// generate a globally unique naming prefix to prevent symbol collisions
 	prefix := fmt.Sprintf("%s_%v_", stub.function.Name, ctx.uid())
 	params := stub.function.CallParameters()
 	var result *semantic.DeclareLocal
 	args := callArguments(ctx, in.Arguments, params, stub.function.Name)
 	// switch scopes back to the one the macro was declared in to prevent symbol leak
 	callScope := ctx.scope
 	ctx.scope = stub.scope
 	defer func() { ctx.scope = callScope }()
 	ctx.with(semantic.VoidType, func() {
 		// put the block back so we inject directly in to it
 		ctx.scope.block = callScope.block
 		// replace parameters with a new uniquely named local variable
 		for i, p := range params {
 			l := addLocal(ctx, nil, p.Name, args[i])
 			// set the unique name after symbol table injection
 			// this means that the lookups inside the macro match the local correctly
 			// but the semantic graph as a globally unique name
 			l.Local.Name = prefix + l.Local.Name
 			ctx.addStatement(l)
 		}
 		// evaluate the macro body in place
 		r := body(ctx, stub.function.AST.Block.Statements, stub.function)
 		// substitute the return statement for a local assignment
 		if r != nil {
 			result = addLocal(ctx, nil, prefix+"result", r.Value)
 			ctx.addStatement(result)
 		}
 	})
 	if result == nil {
 		return invalid{}
 	}
 	return result.Local
 }

 func select_(ctx *context, in *ast.Switch) *semantic.Select {
 	out := &semantic.Select{AST: in}
 	out.Type = nil
 	out.Value = expression(ctx, in.Value)
 	vt := out.Value.ExpressionType()
 	for _, c := range in.Cases {
 		e := choice(ctx, c, vt)
 		out.Choices = append(out.Choices, e)
 		if out.Type == nil {
 			out.Type = e.Expression.ExpressionType()
 		} else if !equal(out.Type, e.Expression.ExpressionType()) {
 			// TODO: This could be a common ancestor type instead?
 			out.Type = semantic.VoidType
 		}
 	}
 	if out.Type == nil {
 		ctx.errorf(in, "could not determine type of switch")
 		out.Type = semantic.VoidType
 	}
 	return out
 }

 // choice translates Case in to a select Choice.
 // vt is the resolved type of the select value being compared against, and can
 // be used to infer the choice condition type.
 func choice(ctx *context, in *ast.Case, vt semantic.Type) *semantic.Choice {
 	out := &semantic.Choice{AST: in}
 	ctx.with(vt, func() {
 		for _, cond := range in.Conditions {
 			exp := expression(ctx, cond)
 			out.Conditions = append(out.Conditions, exp)
 			ct := exp.ExpressionType()
 			if !comparable(vt, ct) {
 				ctx.errorf(cond, "select value %s is not comparable with choice condition %s", typename(vt), typename(ct))
 			}
 		}
 	})
 	if len(in.Block.Statements) != 1 {
 		ctx.errorf(in, "switch case is not a single expression")
 		out.Expression = invalid{}
 		return out
 	}
 	out.Expression = expression(ctx, in.Block.Statements[0])
 	return out
 }

 func member(ctx *context, in *ast.Member) semantic.Expression {
 	obj := expression(ctx, in.Object)
 	ot := obj.ExpressionType()
 	entry := ot.Member(in.Name.Value)
 	if entry == nil {
 		ctx.errorf(in, "%s is not a member of %s", in.Name.Value, typename(ot))
 		return invalid{}
 	}
 	switch entry := entry.(type) {
 	case *semantic.Field:
 		return &semantic.Member{AST: in, Object: obj, Field: entry}
 	case *semantic.Function:
 		return &semantic.Callable{Object: obj, Function: entry}
 	default:
 		ctx.errorf(in, "Invalid member lookup type %T found", entry)
 		return invalid{}
 	}
 }

 func index(ctx *context, in *ast.Index) semantic.Expression {
 	object := expression(ctx, in.Object)
 	at := object.ExpressionType()
 	switch at := at.(type) {
 	case *semantic.Array:
 		out := &semantic.ArrayIndex{AST: in, Array: object}
 		ctx.with(semantic.Int32Type, func() {
 			out.Index = expression(ctx, in.Index)
 		})
 		it := out.Index.ExpressionType()
 		if !equal(it, semantic.Int32Type) && !equal(it, semantic.Uint32Type) {
 			ctx.errorf(in, "type %s not valid indexing array", typename(it))
 		}
 		out.ValueType = at.ValueType
 		return out
 	case *semantic.Map:
 		out := &semantic.MapIndex{AST: in, Map: object}
 		ctx.with(at.KeyType, func() {
 			out.Index = expression(ctx, in.Index)
 		})
 		it := out.Index.ExpressionType()
 		if !comparable(it, at.KeyType) {
 			ctx.errorf(in, "type %s not valid indexing map", typename(it))
 		}
 		out.ValueType = at.ValueType
 		return out
 	default:
 		ctx.errorf(in, "index operation on non indexable type %s", typename(at))
 		return invalid{}
 	}
 }

 func identifier(ctx *context, in *ast.Identifier) semantic.Expression {
 	out := ctx.get(in, in.Value)
 	switch out := out.(type) {
 	case *semantic.Function:
 		return &semantic.Callable{Function: out}
 	case semantic.Expression:
 		return out
 	default:
 		ctx.errorf(in, "Symbol %s was non expression %T", in.Value, out)
 		return invalid{}
 	}
 }

 func classInitializer(ctx *context, in *ast.ClassInitializer) *semantic.ClassInitializer {
 	out := &semantic.ClassInitializer{AST: in}
 	t := type_(ctx, in.Class)
 	class, ok := t.(*semantic.Class)
 	if !ok {
 		ctx.errorf(in.Class, "non class entry %s in extension list", typename(t))
 		return out
 	}
 	out.Class = class
 	for _, f := range in.Fields {
 		out.Fields = append(out.Fields, fieldInitializer(ctx, out.Class, f))
 	}
 	return out
 }

 func fieldInitializer(ctx *context, class *semantic.Class, in *ast.FieldInitializer) *semantic.FieldInitializer {
 	out := &semantic.FieldInitializer{AST: in}
 	m := class.Member(in.Name.Value)
 	if m == nil {
 		ctx.errorf(in.Name, "class %s has no field %s", class.Name, in.Name.Value)
 		return out
 	}
 	field, ok := m.(*semantic.Field)
 	if !ok {
 		ctx.errorf(in.Name, "member %s of class %s is not a field [%T]", in.Name.Value, class.Name, m)
 		return out
 	}
 	out.Field = field
 	ctx.with(field.Type, func() {
 		out.Value = expression(ctx, in.Value)
 	})
 	ft := out.Field.Type
 	vt := out.Value.ExpressionType()
 	if !assignable(ft, vt) {
 		ctx.errorf(in, "field %s cannot assign %s to %s", out.Field.Name, typename(vt), typename(ft))
 	}
 	return out
 }

 func new(ctx *context, in *ast.New) *semantic.New {
 	out := &semantic.New{AST: in}
 	out.Initializer = classInitializer(ctx, in.ClassInitializer)
 	out.Type = getPointerType(ctx, in, out.Initializer.Class)
 	return out
 }

 func cast(ctx *context, in *ast.Cast) semantic.Expression {
 	t := type_(ctx, in.Type)
 	var obj semantic.Expression
 	ctx.with(t, func() {
 		obj = expression(ctx, in.Object)
 	})
 	if equal(t, obj.ExpressionType()) {
 		return obj
 	}
 	out := &semantic.Cast{AST: in, Object: obj, Type: t}
 	if !castable(obj.ExpressionType(), out.Type) {
 		ctx.errorf(in, "cannot cast from %s to %s", typename(obj.ExpressionType()), typename(out.Type))
 	}
 	return out
 }

 func length(ctx *context, in *ast.Length) *semantic.Length {
 	out := &semantic.Length{AST: in}
 	out.Object = expression(ctx, in.Object)
 	at := out.Object.ExpressionType()
 	if at == nil {
 		ctx.errorf(in, "condition was not valid")
 		return out
 	}
 	ok := false
 	switch at.(type) {
 	case *semantic.Array:
 		ok = true
 	case *semantic.Map:
 		ok = true
 	case *semantic.Builtin:
 		if at == semantic.StringType || at == semantic.PointerType {
 			ok = true
 		}
 	}
 	if !ok {
 		ctx.errorf(in, "len cannot work out length of type %s", typename(at))
 		return out
 	}
 	infer := baseType(ctx.scope.inferType)
 	switch infer {
 	case semantic.Int32Type, semantic.Uint32Type, semantic.Int64Type, semantic.Uint64Type:
 		out.Type = infer
 	default:
 		out.Type = semantic.Int32Type
 	}
 	return out
 }

 func number(ctx *context, in *ast.Number) semantic.Expression {
 	infer := baseType(ctx.scope.inferType)
 	out := inferNumber(ctx, in, infer)
 	if out != nil {
 		if infer == ctx.scope.inferType {
 			return out
 		}
 		return &semantic.Cast{Type: ctx.scope.inferType, Object: out}
 	}
 	if v, err := strconv.ParseInt(in.Value, 0, 32); err == nil {
 		return semantic.Int32Value(v)
 	}
 	if v, err := strconv.ParseFloat(in.Value, 64); err == nil {
 		return semantic.Float64Value(v)
 	}
 	ctx.errorf(in, "could not parse %s as a number (%s)", in.Value, typename(infer))
 	return invalid{}
 }
	// Copyright (C) 2014 The Android Open Source Project
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	package resolver

	import (
	"fmt"
	"strconv"

	"android.googlesource.com/platform/tools/gpu/api/ast"
	"android.googlesource.com/platform/tools/gpu/api/semantic"
	)

	type invalid struct{}

	func (invalid) ExpressionType() semantic.Type { return semantic.VoidType }

	// expression translates the ast expression to a semantic expression.
	func expression(ctx *context, in interface{}) semantic.Expression {
	switch in := in.(type) {
	case *ast.UnaryOp:
	return unaryOp(ctx, in)
	case *ast.BinaryOp:
	return binaryOp(ctx, in)
	case *ast.Call:
	return call(ctx, in)
	case *ast.Switch:
	return select_(ctx, in)
	case *ast.Member:
	return member(ctx, in)
	case *ast.Index:
	return index(ctx, in)
	case *ast.Identifier:
	return identifier(ctx, in)
	case *ast.ClassInitializer:
	return classInitializer(ctx, in)
	case *ast.New:
	return new(ctx, in)
	case *ast.Group:
	return expression(ctx, in.Expression)
	case *ast.Cast:
	return cast(ctx, in)
	case *ast.Length:
	return length(ctx, in)
	case *ast.Unknown:
	return &semantic.Unknown{AST: in}
	case *ast.Number:
	return number(ctx, in)
	case *ast.Bool:
	return semantic.BoolValue(in.Value)
	case *ast.String:
	return semantic.StringValue(in.Value)
	default:
	ctx.icef(in, "Unhandled expression type %T found", in)
	return invalid{}
	}
	}

	func call(ctx context, in ast.Call) semantic.Expression {
	target := expression(ctx, in.Target)
	switch target := target.(type) {
	case *macroStub:
	return macroCall(ctx, in, target)
	case *semantic.Callable:
	return functionCall(ctx, in, target)
	default:
	ctx.errorf(in, "Invalid method call target %T found", target)
	return invalid{}
	}
	}

	func callArguments(ctx context, in []interface{}, params []semantic.Parameter, name string) []semantic.Expression {
	out := []semantic.Expression{}
	if len(params) != len(in) {
	ctx.errorf(in, "wrong number of arguments to %s, expected %v got %v", name, len(params), len(in))
	return out
	}
	for i, a := range in {
	p := params[i]
	ctx.with(p.Type, func() {
	arg := expression(ctx, a)
	at := arg.ExpressionType()
	out = append(out, arg)
	if !assignable(p.Type, at) {
	ctx.errorf(a, "argument %d to %s is wrong type, expected %s got %s", i, name, typename(p.Type), typename(at))
	}
	})
	}
	return out
	}

	func functionCall(ctx context, in ast.Call, target semantic.Callable) semantic.Call {
	out := &semantic.Call{AST: in, Target: target, Type: semantic.VoidType}
	params := target.Function.FullParameters
	if target.Object != nil {
	if target.Function.This == nil {
	ctx.errorf(in, "method call on non method %s of %T", target.Function.Name, target.Object)
	return out
	}
	params = params[1:len(params)]
	}
	if target.Function.Return.Type != semantic.VoidType {
	params = params[0 : len(params)-1]
	}
	out.Arguments = callArguments(ctx, in.Arguments, params, target.Function.Name)
	out.Type = out.Target.Function.Return.Type
	return out
	}

	func macroCall(ctx context, in ast.Call, stub *macroStub) semantic.Expression {
	if ctx.scope.block == nil {
	ctx.errorf(in, "macro call outside of block scope")
	return invalid{}
	}
	// generate a globally unique naming prefix to prevent symbol collisions
	prefix := fmt.Sprintf("%s_%v_", stub.function.Name, ctx.uid())
	params := stub.function.CallParameters()
	var result *semantic.DeclareLocal
	args := callArguments(ctx, in.Arguments, params, stub.function.Name)
	// switch scopes back to the one the macro was declared in to prevent symbol leak
	callScope := ctx.scope
	ctx.scope = stub.scope
	defer func() { ctx.scope = callScope }()
	ctx.with(semantic.VoidType, func() {
	// put the block back so we inject directly in to it
	ctx.scope.block = callScope.block
	// replace parameters with a new uniquely named local variable
	for i, p := range params {
	l := addLocal(ctx, nil, p.Name, args[i])
	// set the unique name after symbol table injection
	// this means that the lookups inside the macro match the local correctly
	// but the semantic graph as a globally unique name
	l.Local.Name = prefix + l.Local.Name
	ctx.addStatement(l)
	}
	// evaluate the macro body in place
	r := body(ctx, stub.function.AST.Block.Statements, stub.function)
	// substitute the return statement for a local assignment
	if r != nil {
	result = addLocal(ctx, nil, prefix+"result", r.Value)
	ctx.addStatement(result)
	}
	})
	if result == nil {
	return invalid{}
	}
	return result.Local
	}

	func select_(ctx context, in ast.Switch) *semantic.Select {
	out := &semantic.Select{AST: in}
	out.Type = nil
	out.Value = expression(ctx, in.Value)
	vt := out.Value.ExpressionType()
	for _, c := range in.Cases {
	e := choice(ctx, c, vt)
	out.Choices = append(out.Choices, e)
	if out.Type == nil {
	out.Type = e.Expression.ExpressionType()
	} else if !equal(out.Type, e.Expression.ExpressionType()) {
	// TODO: This could be a common ancestor type instead?
	out.Type = semantic.VoidType
	}
	}
	if out.Type == nil {
	ctx.errorf(in, "could not determine type of switch")
	out.Type = semantic.VoidType
	}
	return out
	}

	// choice translates Case in to a select Choice.
	// vt is the resolved type of the select value being compared against, and can
	// be used to infer the choice condition type.
	func choice(ctx context, in ast.Case, vt semantic.Type) *semantic.Choice {
	out := &semantic.Choice{AST: in}
	ctx.with(vt, func() {
	for _, cond := range in.Conditions {
	exp := expression(ctx, cond)
	out.Conditions = append(out.Conditions, exp)
	ct := exp.ExpressionType()
	if !comparable(vt, ct) {
	ctx.errorf(cond, "select value %s is not comparable with choice condition %s", typename(vt), typename(ct))
	}
	}
	})
	if len(in.Block.Statements) != 1 {
	ctx.errorf(in, "switch case is not a single expression")
	out.Expression = invalid{}
	return out
	}
	out.Expression = expression(ctx, in.Block.Statements[0])
	return out
	}

	func member(ctx context, in ast.Member) semantic.Expression {
	obj := expression(ctx, in.Object)
	ot := obj.ExpressionType()
	entry := ot.Member(in.Name.Value)
	if entry == nil {
	ctx.errorf(in, "%s is not a member of %s", in.Name.Value, typename(ot))
	return invalid{}
	}
	switch entry := entry.(type) {
	case *semantic.Field:
	return &semantic.Member{AST: in, Object: obj, Field: entry}
	case *semantic.Function:
	return &semantic.Callable{Object: obj, Function: entry}
	default:
	ctx.errorf(in, "Invalid member lookup type %T found", entry)
	return invalid{}
	}
	}

	func index(ctx context, in ast.Index) semantic.Expression {
	object := expression(ctx, in.Object)
	at := object.ExpressionType()
	switch at := at.(type) {
	case *semantic.Array:
	out := &semantic.ArrayIndex{AST: in, Array: object}
	ctx.with(semantic.Int32Type, func() {
	out.Index = expression(ctx, in.Index)
	})
	it := out.Index.ExpressionType()
	if !equal(it, semantic.Int32Type) && !equal(it, semantic.Uint32Type) {
	ctx.errorf(in, "type %s not valid indexing array", typename(it))
	}
	out.ValueType = at.ValueType
	return out
	case *semantic.Map:
	out := &semantic.MapIndex{AST: in, Map: object}
	ctx.with(at.KeyType, func() {
	out.Index = expression(ctx, in.Index)
	})
	it := out.Index.ExpressionType()
	if !comparable(it, at.KeyType) {
	ctx.errorf(in, "type %s not valid indexing map", typename(it))
	}
	out.ValueType = at.ValueType
	return out
	default:
	ctx.errorf(in, "index operation on non indexable type %s", typename(at))
	return invalid{}
	}
	}

	func identifier(ctx context, in ast.Identifier) semantic.Expression {
	out := ctx.get(in, in.Value)
	switch out := out.(type) {
	case *semantic.Function:
	return &semantic.Callable{Function: out}
	case semantic.Expression:
	return out
	default:
	ctx.errorf(in, "Symbol %s was non expression %T", in.Value, out)
	return invalid{}
	}
	}

	func classInitializer(ctx context, in ast.ClassInitializer) *semantic.ClassInitializer {
	out := &semantic.ClassInitializer{AST: in}
	t := type_(ctx, in.Class)
	class, ok := t.(*semantic.Class)
	if !ok {
	ctx.errorf(in.Class, "non class entry %s in extension list", typename(t))
	return out
	}
	out.Class = class
	for _, f := range in.Fields {
	out.Fields = append(out.Fields, fieldInitializer(ctx, out.Class, f))
	}
	return out
	}

	func fieldInitializer(ctx context, class semantic.Class, in ast.FieldInitializer) semantic.FieldInitializer {
	out := &semantic.FieldInitializer{AST: in}
	m := class.Member(in.Name.Value)
	if m == nil {
	ctx.errorf(in.Name, "class %s has no field %s", class.Name, in.Name.Value)
	return out
	}
	field, ok := m.(*semantic.Field)
	if !ok {
	ctx.errorf(in.Name, "member %s of class %s is not a field [%T]", in.Name.Value, class.Name, m)
	return out
	}
	out.Field = field
	ctx.with(field.Type, func() {
	out.Value = expression(ctx, in.Value)
	})
	ft := out.Field.Type
	vt := out.Value.ExpressionType()
	if !assignable(ft, vt) {
	ctx.errorf(in, "field %s cannot assign %s to %s", out.Field.Name, typename(vt), typename(ft))
	}
	return out
	}

	func new(ctx context, in ast.New) *semantic.New {
	out := &semantic.New{AST: in}
	out.Initializer = classInitializer(ctx, in.ClassInitializer)
	out.Type = getPointerType(ctx, in, out.Initializer.Class)
	return out
	}

	func cast(ctx context, in ast.Cast) semantic.Expression {
	t := type_(ctx, in.Type)
	var obj semantic.Expression
	ctx.with(t, func() {
	obj = expression(ctx, in.Object)
	})
	if equal(t, obj.ExpressionType()) {
	return obj
	}
	out := &semantic.Cast{AST: in, Object: obj, Type: t}
	if !castable(obj.ExpressionType(), out.Type) {
	ctx.errorf(in, "cannot cast from %s to %s", typename(obj.ExpressionType()), typename(out.Type))
	}
	return out
	}

	func length(ctx context, in ast.Length) *semantic.Length {
	out := &semantic.Length{AST: in}
	out.Object = expression(ctx, in.Object)
	at := out.Object.ExpressionType()
	if at == nil {
	ctx.errorf(in, "condition was not valid")
	return out
	}
	ok := false
	switch at.(type) {
	case *semantic.Array:
	ok = true
	case *semantic.Map:
	ok = true
	case *semantic.Builtin:
	if at == semantic.StringType \|\| at == semantic.PointerType {
	ok = true
	}
	}
	if !ok {
	ctx.errorf(in, "len cannot work out length of type %s", typename(at))
	return out
	}
	infer := baseType(ctx.scope.inferType)
	switch infer {
	case semantic.Int32Type, semantic.Uint32Type, semantic.Int64Type, semantic.Uint64Type:
	out.Type = infer
	default:
	out.Type = semantic.Int32Type
	}
	return out
	}

	func number(ctx context, in ast.Number) semantic.Expression {
	infer := baseType(ctx.scope.inferType)
	out := inferNumber(ctx, in, infer)
	if out != nil {
	if infer == ctx.scope.inferType {
	return out
	}
	return &semantic.Cast{Type: ctx.scope.inferType, Object: out}
	}
	if v, err := strconv.ParseInt(in.Value, 0, 32); err == nil {
	return semantic.Int32Value(v)
	}
	if v, err := strconv.ParseFloat(in.Value, 64); err == nil {
	return semantic.Float64Value(v)
	}
	ctx.errorf(in, "could not parse %s as a number (%s)", in.Value, typename(infer))
	return invalid{}
	}