quantize type inference

global.c

 {
 	struct node *map = n->expr.args;
 
-	if (n->sym->type || !map->sym->type)
+	if (!map->sym->type)
 		return 0;
 
-	assert(map->sym->type->ttype == T_MAP);
+	/* TODO validate key against known type */
 
 	/* given `m[key]` where m's type is known, infer that the
 	 * expression's type is equal to m's value type. */
 {
 	struct node *lval, *rval;
 
+	if (n->sym->type)
+		return 0;
+
 	lval = n->expr.args;
 	rval = lval->next;
 
 		 * infer that a's type must be equal to b's */
 		lval->sym->type = rval->sym->type;
 
+		/* TODO do we need assignment expressions? */
+		n->sym->type = &t_void;
+
 		if (node_is_map(lval))
 			return global_assign_type_infer_map(lval);
 
 
 	_e("%#N: can't assign %N (type '%T'), to %N (type '%T').\n",
 	   n, rval, rval->sym->type, lval, lval->sym->type);
+
 	return -EINVAL;
 }
 
 {
 	struct node *lval, *rval;
 
+	if (n->sym->type)
+		return 0;
+
 	lval = n->expr.args;
 	rval = lval->next;
 
-	if (n->sym->type || !lval->sym->type || !rval->sym->type)
+	if (!lval->sym->type || !rval->sym->type)
 		return 0;
 
 	if (type_equal(lval->sym->type, rval->sym->type)) {
 	return 0;
 }
 
+/* :binop */
+
+static int global_quantize_type_infer(const struct func *func, struct node *n)
+{
+	struct node *arg;
+	struct type *t;
+
+	arg = n->expr.args;
+
+	if (n->sym->type || !arg->sym->type)
+		return 0;
+
+	t = type_base(arg->sym->type);
+	if (t->ttype != T_SCALAR) {
+		_e("%#N: can't quantize non-scalar value %N (type '%T').\n",
+		   n, arg, arg->sym->type);
+		return -EINVAL;	
+	}
+
+	n->sym->type = type_array_of(arg->sym->type, type_sizeof(t) * 8);
+	return 0;
+}
+
 /* pid */
 
 struct type t_pid = {
 	{
 		.name = "quantize",
 		.type = &t_1arg_func,
+		.type_infer = global_quantize_type_infer,
 	},
 	
 	{ .name = NULL }

type.h

 
 }
 
+static inline struct type *type_base(struct type *t)
+{
+	while (t->ttype == T_TYPEDEF)
+		t = t->tdef.type;
+
+	return t;
+}
+
 #endif	/* _PLY_TYPE_H */