code review 1303042: gc: new typechecking rules

src/cmd/gc/walk.c

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 #include        "go.h"
 
 static  Node*   walkprint(Node*, NodeList**, int);
 static  Node*   conv(Node*, Type*);
 static  Node*   mapfn(char*, Type*);
 static  Node*   makenewvar(Type*, NodeList**, Node**);
 
-enum
-{
-        Inone,
-        I2T,
-        I2T2,
-        I2I,
-        I2Ix,
-        I2I2,
-        T2I,
-        I2Isame,
-        E2T,
-        E2T2,
-        E2I,
-        E2I2,
-        I2E,
-        I2E2,
-        T2E,
-        E2Esame,
-};
-
 // can this code branch reach the end
 // without an undcontitional RETURN
 // this is hard, so it is conservative
 int
 walkret(NodeList *l)
 {
         Node *n;
 
 loop:
         while(l && l->next)
@@ skipping 120 matching lines @@
         t = n->type;
         t->sym = n->sym;
         t->local = n->local;
         t->vargen = n->vargen;
         t->siggen = 0;
         t->method = nil;
         t->nod = N;
         t->printed = 0;
         t->deferwidth = 0;
 
-        // double-check use of type as map key
-        // TODO(rsc): also use of type as receiver?
+        // double-check use of type as map key.
         if(maplineno) {
                 lineno = maplineno;
                 maptype(n->type, types[TBOOL]);
         }
         if(embedlineno) {
                 lineno = embedlineno;
                 if(isptr[t->etype])
                         yyerror("embedded type cannot be a pointer");
         }
 
@@ skipping 250 matching lines @@
                 default:
                         walkexpr(&n->left, &n->ninit);
                         break;
                 }
                 break;
 
         case OFOR:
                 walkstmtlist(n->ninit);
                 if(n->ntest != N) {
                         walkstmtlist(n->ntest->ninit);
-                        walkexpr(&n->ntest, &n->ninit);
+                        init = n->ntest->ninit;
+                        n->ntest->ninit = nil;
+                        walkexpr(&n->ntest, &init);
+                        n->ntest->ninit = concat(init, n->ntest->ninit);
                 }
                 walkstmt(&n->nincr);
                 walkstmtlist(n->nbody);
                 break;
 
         case OIF:
                 walkstmtlist(n->ninit);
                 walkexpr(&n->ntest, &n->ninit);
                 walkstmtlist(n->nbody);
                 walkstmtlist(n->nelse);
@@ skipping 21 matching lines @@
                         if(samelist(rl, n->list)) {
                                 // special return in disguise
                                 n->list = nil;
                                 break;
                         }
                         ll = ascompatee(n->op, rl, n->list, &n->ninit);
                         n->list = reorder3(ll);
                         break;
                 }
                 ll = ascompatte(n->op, getoutarg(curfn->type), n->list, 1, &n->ninit);
-                n->list = reorder4(ll);
+                n->list = ll;
                 break;
 
         case OSELECT:
                 walkselect(n);
                 break;
 
         case OSWITCH:
                 walkswitch(n);
                 break;
 
@@ skipping 37 matching lines @@
 
 void
 walkexpr(Node **np, NodeList **init)
 {
         Node *r, *l, *var, *a;
         NodeList *ll, *lr, *lpost;
         Type *t;
         int et;
         int32 lno;
         Node *n, *fn;
+        char buf[100], *p;
 
         n = *np;
 
         if(n == N)
                 return;
 
         if(init == &n->ninit) {
                 // not okay to use n->ninit when walking n,
                 // because we might replace n with some other node
                 // and would lose the init list.
@@ skipping 110 matching lines @@
                 walkexprlist(n->list, init);
                 ll = ascompatte(n->op, getinarg(t), n->list, 0, init);
                 n->list = reorder1(ll);
                 if(isselect(n)) {
                         // special prob with selectsend and selectrecv:
                         // if chan is nil, they don't know big the channel
                         // element is and therefore don't know how to find
                         // the output bool, so we clear it before the call.
                         Node *b;
                         b = nodbool(0);
+                        typecheck(&b, Erv);
                         lr = ascompatte(n->op, getoutarg(t), list1(b), 0, init);
                         n->list = concat(n->list, lr);
                 }
                 goto ret;
 
         case OCALLMETH:
                 t = n->left->type;
                 if(n->list && n->list->n->op == OAS)
                         goto ret;
                 walkexpr(&n->left, init);
@@ skipping 19 matching lines @@
                 if(l == N || r == N)
                         goto ret;
                 r = ascompatee1(n->op, l, r, init);
                 if(r != N) {
                         r->dodata = n->dodata;
                         n = r;
                 }
                 goto ret;
 
         case OAS2:
-        as2:
                 *init = concat(*init, n->ninit);
                 n->ninit = nil;
                 walkexprlistsafe(n->list, init);
                 walkexprlistsafe(n->rlist, init);
                 ll = ascompatee(OAS, n->list, n->rlist, init);
                 ll = reorder3(ll);
                 n = liststmt(ll);
                 goto ret;
 
         case OAS2FUNC:
@@ skipping 71 matching lines @@
                 t = l->left->type;
                 n = mkcall1(mapfn("mapassign2", t), T, init, l->left, l->right, n->rlist->n, n->rlist->next->n);
                 goto ret;
 
         case OAS2DOTTYPE:
                 // a,b = i.(T)
                 *init = concat(*init, n->ninit);
                 n->ninit = nil;
                 r = n->rlist->n;
                 walkexprlistsafe(n->list, init);
-                walkdottype(r, init);
-                et = ifaceas1(r->type, r->left->type, 1);
-                switch(et) {
-                case I2Isame:
-                case E2Esame:
-                case I2E:
-                        n->rlist = list(list1(r->left), nodbool(1));
-                        typechecklist(n->rlist, Erv);
-                        goto as2;
-                case I2T:
-                        et = I2T2;
-                        break;
-                case I2Ix:
-                        et = I2I2;
-                        break;
-                case E2I:
-                        et = E2I2;
-                        break;
-                case E2T:
-                        et = E2T2;
-                        break;
-                default:
-                        et = Inone;
-                        break;
-                }
-                if(et == Inone)
-                        break;
-                r = ifacecvt(r->type, r->left, et, init);
+                r->op = ODOTTYPE2;
+                walkexpr(&r, init);
                 ll = ascompatet(n->op, n->list, &r->type, 0, init);
                 n = liststmt(concat(list1(r), ll));
                 goto ret;
 
         case ODOTTYPE:
-                walkdottype(n, init);
-                walkconv(&n, init);
+        case ODOTTYPE2:  ·······
+                // Build name of function: assertI2E2 etc.
+                strcpy(buf, "assert");
+                p = buf+strlen(buf);
+                if(isnilinter(n->left->type))
+                        *p++ = 'E';
+                else
+                        *p++ = 'I';
+                *p++ = '2';
+                if(isnilinter(n->type))
+                        *p++ = 'E';
+                else if(isinter(n->type))
+                        *p++ = 'I';
+                else
+                        *p++ = 'T';
+                if(n->op == ODOTTYPE2)
+                        *p++ = '2';
+                *p = '\0';
+ ·······
+                fn = syslook(buf, 1);
+                ll = list1(typename(n->type));
+                ll = list(ll, n->left);
+                argtype(fn, n->left->type);
+                argtype(fn, n->type);
+                n = nod(OCALL, fn, N);
+                n->list = ll;
+                typecheck(&n, Erv | Efnstruct);
+                walkexpr(&n, init);
+                goto ret;
+
+        case OCONVIFACE:
+                // Build name of function: convI2E etc.
+                // Not all names are possible
+                // (e.g., we'll never generate convE2E or convE2I).
+                walkexpr(&n->left, init);
+                strcpy(buf, "conv");
+                p = buf+strlen(buf);
+                if(isnilinter(n->left->type))
+                        *p++ = 'E';
+                else if(isinter(n->left->type))
+                        *p++ = 'I';
+                else
+                        *p++ = 'T';
+                *p++ = '2';
+                if(isnilinter(n->type))
+                        *p++ = 'E';
+                else
+                        *p++ = 'I';
+                *p = '\0';
+         ·······
+                fn = syslook(buf, 1);
+                ll = nil;
+                if(!isinter(n->left->type))
+                        ll = list(ll, typename(n->left->type));
+                if(!isnilinter(n->type))
+                        ll = list(ll, typename(n->type));
+                ll = list(ll, n->left);
+                argtype(fn, n->left->type);
+                argtype(fn, n->type);
+                dowidth(fn->type);
+                n = nod(OCALL, fn, N);
+                n->list = ll;
+                typecheck(&n, Erv);
+                walkexpr(&n, init);
                 goto ret;
 
         case OCONV:
         case OCONVNOP:
                 if(thechar == '5') {
                         if(isfloat[n->left->type->etype] &&
                            (n->type->etype == TINT64 || n->type->etype == TUINT64)) {
                                 n = mkcall("float64toint64", n->type, init, conv(n->left, types[TFLOAT64]));
                                 goto ret;
                         }
@@ skipping 319 matching lines @@
                 argtype(fn, t->type);                   // any-1
                 n = mkcall1(fn, n->type, init,
                         typename(n->type),
                         conv(l, types[TINT64]),
                         conv(r, types[TINT64]));
                 goto ret;
 
         case ORUNESTR:
                 // sys_intstring(v)
                 n = mkcall("intstring", n->type, init,
-                        conv(n->left, types[TINT64]));  // TODO(rsc): int64?!
+                        conv(n->left, types[TINT64]));
                 goto ret;
 
         case OARRAYBYTESTR:
                 // slicebytetostring([]byte) string;
                 n = mkcall("slicebytetostring", n->type, init, n->left);
                 goto ret;
 
         case OARRAYRUNESTR:
                 // sliceinttostring([]int) string;
                 n = mkcall("sliceinttostring", n->type, init, n->left);
@@ skipping 37 matching lines @@
                 goto ret;
 
         case OSEND:
                 n = mkcall1(chanfn("chansend1", 2, n->left->type), T, init, n->left, n->right);
                 goto ret;
 
         case OSENDNB:
                 n = mkcall1(chanfn("chansend2", 2, n->left->type), n->type, init, n->left, n->right);
                 goto ret;
 
-        case OCONVIFACE:
-                walkexpr(&n->left, init);
-                n = ifacecvt(n->type, n->left, n->etype, init);
-                goto ret;
-
         case OCLOSURE:
                 n = walkclosure(n, init);
                 goto ret;
         }
         fatal("missing switch %O", n->op);
 
 ret:
         if(debug['w'] && n != N)
                 dump("walk", n);
 
@@ skipping 12 matching lines @@
         nas = nod(OAS, nvar, callnew(t->type));
         typecheck(&nas, Etop);
         walkexpr(&nas, init);
         *init = list(*init, nas);
 
         *nstar = nod(OIND, nvar, N);
         typecheck(nstar, Erv);
         return nvar;
 }
 
-// TODO(rsc): cut
-void
-walkdottype(Node *n, NodeList **init)
-{
-        walkexpr(&n->left, init);
-        if(n->left == N)
-                return;
-        if(n->right != N) {
-                walkexpr(&n->right, init);
-                n->type = n->right->type;
-                n->right = N;
-        }
-}
-
-// TODO(rsc): cut
-void
-walkconv(Node **np, NodeList **init)
-{
-        int et;
-        char *what;
-        Type *t;
-        Node *l;
-        Node *n;
-
-        n = *np;
-        t = n->type;
-        if(t == T)
-                return;
-        walkexpr(&n->left, init);
-        l = n->left;
-        if(l == N)
-                return;
-        if(l->type == T)
-                return;
-
-        // if using .(T), interface assertion.
-        if(n->op == ODOTTYPE) {
-                et = ifaceas1(t, l->type, 1);
-                if(et == I2Isame || et == E2Esame) {
-                        n->op = OCONVNOP;
-                        return;
-                }
-                if(et != Inone) {
-                        n = ifacecvt(t, l, et, init);
-                        *np = n;
-                        return;
-                }
-                goto bad;
-        }
-
-        fatal("walkconv");
-
-bad:
-        if(n->diag)
-                return;
-        n->diag = 1;
-        if(n->op == ODOTTYPE)
-                what = "type assertion";
-        else
-                what = "conversion";
-        if(l->type != T)
-                yyerror("invalid %s: %T to %T", what, l->type, t);
-}
-
 Node*
 ascompatee1(int op, Node *l, Node *r, NodeList **init)
 {
         return convas(nod(OAS, l, r), init);
 }
 
 NodeList*
 ascompatee(int op, NodeList *nl, NodeList *nr, NodeList **init)
 {
         NodeList *ll, *lr, *nn;
@@ skipping 63 matching lines @@
                         r = structnext(&saver);
                         continue;
                 }
 
                 // any lv that causes a fn call must be
                 // deferred until all the return arguments
                 // have been pulled from the output arguments
                 if(fncall(l, r->type)) {
                         tmp = nod(OXXX, N, N);
                         tempname(tmp, r->type);
+                        typecheck(&tmp, Erv);
                         a = nod(OAS, l, tmp);
                         a = convas(a, init);
                         mm = list(mm, a);
                         l = tmp;
                 }
 
                 a = nod(OAS, l, nodarg(r, fp));
                 a = convas(a, init);
                 ullmancalc(a);
                 if(a->ullman >= UINF)
@@ skipping 79 matching lines @@
         }
 
         // make a named type for the struct
         st = sigtype(st);
         dowidth(st);
 
         // now we have the size, make the struct
         var = nod(OXXX, N, N);
         tempname(var, st);
         var->sym = lookup(".ddd");
+        typecheck(&var, Erv);
 
         // assign the fields to the struct.
         // use the init list so that reorder1 doesn't reorder
         // these assignments after the interface conversion
         // below.
         t = st->type;
         for(lr=n; lr; lr=lr->next) {
                 r = lr->n;
                 r->left = nod(OXXX, N, N);
                 *r->left = *var;
@@ skipping 390 matching lines @@
 
         dowidth(t->type);
 
         return t;
 
 bad:
         yyerror("not a channel: %lT", t);
         return T;
 }
 
-/*
- * assigning src to dst involving interfaces?
- * return op to use.
- */
-int
-ifaceas1(Type *dst, Type *src, int explicit)
-{
-        if(src == T || dst == T)
-                return Inone;
-
-        if(explicit && !isinter(src))
-                yyerror("cannot use .(T) on non-interface type %T", src);
-
-        if(isinter(dst)) {
-                if(isinter(src)) {
-                        if(isnilinter(dst)) {
-                                if(isnilinter(src))
-                                        return E2Esame;
-                                return I2E;
-                        }
-                        if(eqtype(dst, src))
-                                return I2Isame;
-                        ifacecheck(dst, src, lineno, explicit);
-                        if(isnilinter(src))
-                                return E2I;
-                        if(explicit)
-                                return I2Ix;
-                        return I2I;
-                }
-                if(isnilinter(dst))
-                        return T2E;
-                ifacecheck(dst, src, lineno, explicit);
-                return T2I;
-        }
-        if(isinter(src)) {
-                ifacecheck(dst, src, lineno, explicit);
-                if(isnilinter(src))
-                        return E2T;
-                return I2T;
-        }
-        return Inone;
-}
-
-/*
- * treat convert T to T as noop
- */
-int
-ifaceas(Type *dst, Type *src, int explicit)
-{
-        int et;
-
-        et = ifaceas1(dst, src, explicit);
-        if(et == I2Isame || et == E2Esame)
-                et = Inone;
-        return et;
-}
-
-static  char*
-ifacename[] =
-{
-        [I2T]           = "ifaceI2T",
-        [I2T2]          = "ifaceI2T2",
-        [I2I]           = "ifaceI2I",
-        [I2Ix]          = "ifaceI2Ix",
-        [I2I2]          = "ifaceI2I2",
-        [I2Isame]       = "ifaceI2Isame",
-        [E2T]           = "ifaceE2T",
-        [E2T2]          = "ifaceE2T2",
-        [E2I]           = "ifaceE2I",
-        [E2I2]          = "ifaceE2I2",
-        [I2E]           = "ifaceI2E",
-        [I2E2]          = "ifaceI2E2",
-        [T2I]           = "ifaceT2I",
-        [T2E]           = "ifaceT2E",
-        [E2Esame]       = "ifaceE2Esame",
-};
-
-Node*
-ifacecvt(Type *tl, Node *n, int et, NodeList **init)
-{
-        Type *tr;
-        Node *r, *on;
-        NodeList *args;
-
-        tr = n->type;
-
-        switch(et) {
-        default:
-                fatal("ifacecvt: unknown op %d\n", et);
-
-        case I2Isame:
-        case E2Esame:
-                return n;
-
-        case T2I:
-                // ifaceT2I(sigi *byte, sigt *byte, elem any) (ret any);
-                args = list1(typename(tl));     // sigi
-                args = list(args, typename(tr));        // sigt
-                args = list(args, n);   // elem
-
-                on = syslook("ifaceT2I", 1);
-                argtype(on, tr);
-                argtype(on, tl);
-                dowidth(on->type);
-                break;
-
-        case I2T:
-        case I2T2:
-        case I2I:
-        case I2Ix:
-        case I2I2:
-        case E2T:
-        case E2T2:
-        case E2I:
-        case E2I2:
-                // iface[IT]2[IT][2](sigt *byte, iface any) (ret any[, ok bool]);
-                args = list1(typename(tl));     // sigi or sigt
-                args = list(args, n);           // iface
-
-                on = syslook(ifacename[et], 1);
-                argtype(on, tr);
-                argtype(on, tl);
-                break;
-
-        case I2E:
-                // TODO(rsc): Should do this in back end, without a call.
-                // ifaceI2E(elem any) (ret any);
-                args = list1(n);        // elem
-
-                on = syslook("ifaceI2E", 1);
-                argtype(on, tr);
-                argtype(on, tl);
-                break;
-
-        case T2E:
-                // TODO(rsc): Should do this in back end for pointer case, without a call.
-                // ifaceT2E(sigt *byte, elem any) (ret any);
-                args = list1(typename(tr));     // sigt
-                args = list(args, n);           // elem
-
-                on = syslook("ifaceT2E", 1);
-                argtype(on, tr);
-                argtype(on, tl);
-                break;
-        }
-
-        dowidth(on->type);
-        r = nod(OCALL, on, N);
-        r->list = args;
-        typecheck(&r, Erv | Efnstruct);
-        walkexpr(&r, init);
-        return r;
-}
-
 Node*
 convas(Node *n, NodeList **init)
 {
         Node *l, *r;
         Type *lt, *rt;
-        int et;
 
         if(n->op != OAS)
                 fatal("convas: not OAS %O", n->op);
         n->typecheck = 1;
 
         lt = T;
         rt = T;
 
         l = n->left;
         r = n->right;
         if(l == N || r == N)
                 goto out;
 
         lt = l->type;
         rt = r->type;
         if(lt == T || rt == T)
                 goto out;
 
         if(isblank(n->left)) {
                 defaultlit(&n->right, T);
                 goto out;
         }
 
         if(n->left->op == OINDEXMAP) {
                 n = mkcall1(mapfn("mapassign1", n->left->left->type), T, init,
                         n->left->left, n->left->right, n->right);
                 goto out;
         }
-
+        
         if(eqtype(lt, rt))
                 goto out;
-
-        et = ifaceas(lt, rt, 0);
-        if(et != Inone) {
-                n->right = ifacecvt(lt, r, et, init);
-                goto out;
-        }
+ ·······
+        n->right = assignconv(r, lt, "assignment");
+        walkexpr(&n->right, init);
 
 out:
         ullmancalc(n);
         return n;
 }
 
 /*
  * from ascompat[te]
  * evaluating actual function arguments.
  *      f(a,b)
@@ skipping 148 matching lines @@
                                         n1->left = q->right;
                                         r = list(r, q);
                                         break;
                                 }
                         }
                 }
         }
         return concat(all, r);
 }
 
-NodeList*
-reorder4(NodeList *ll)
-{
-        /*
-         * from ascompat[te]
-         *      return c,d
-         * return expression assigned to output
-         * parameters. there may be no problems.
-         *
-         * TODO(rsc): i don't believe that.
-         *      func f() (a, b int) {
-         *              a, b = 1, 2;
-         *              return b, a;
-         *      }
-         */
-        return ll;
-}
-
 /*
  * walk through argin parameters.
  * generate and return code to allocate
  * copies of escaped parameters to the heap.
  */
 NodeList*
 paramstoheap(Type **argin, int out)
 {
         Type *t;
         Iter savet;
@@ skipping 142 matching lines @@
 
         if(t->etype != TMAP)
                 fatal("mapfn %T", t);
         fn = syslook(name, 1);
         argtype(fn, t->down);
         argtype(fn, t->type);
         argtype(fn, t->down);
         argtype(fn, t->type);
         return fn;
 }