diff --git a/gnovm/pkg/gnolang/preprocess.go b/gnovm/pkg/gnolang/preprocess.go
index 78b11a4ebc5..6e749053d72 100644
--- a/gnovm/pkg/gnolang/preprocess.go
+++ b/gnovm/pkg/gnolang/preprocess.go
@@ -743,7 +743,7 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 					for i, cx := range n.Cases {
 						cx = Preprocess(
 							store, last, cx).(Expr)
-						checkOrConvertType(store, last, &cx, tt, false) // #nosec G601
+						checkOrConvertType(store, last, n, &cx, tt, false) // #nosec G601
 						n.Cases[i] = cx
 					}
 				}
@@ -882,7 +882,7 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 				// Preprocess and convert tag if const.
 				if n.X != nil {
 					n.X = Preprocess(store, last, n.X).(Expr)
-					convertIfConst(store, last, n.X)
+					convertIfConst(store, last, n, n.X)
 				}
 			}
 			return n, TRANS_CONTINUE
@@ -1102,10 +1102,10 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 						// First, convert untyped as necessary.
 						if !shouldSwapOnSpecificity(lcx.T, rcx.T) {
 							// convert n.Left to right type.
-							checkOrConvertType(store, last, &n.Left, rcx.T, false)
+							checkOrConvertType(store, last, n, &n.Left, rcx.T, false)
 						} else {
 							// convert n.Right to left type.
-							checkOrConvertType(store, last, &n.Right, lcx.T, false)
+							checkOrConvertType(store, last, n, &n.Right, lcx.T, false)
 						}
 						// Then, evaluate the expression.
 						cx := evalConst(store, last, n)
@@ -1125,7 +1125,7 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 									rnt.String()))
 							}
 							// convert n.Left to pt type,
-							checkOrConvertType(store, last, &n.Left, pt, false)
+							checkOrConvertType(store, last, n, &n.Left, pt, false)
 							// if check pass, convert n.Right to (gno) pt type,
 							rn := Expr(Call(pt.String(), n.Right))
 							// and convert result back.
@@ -1154,7 +1154,7 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 							}
 
 							if !isUntyped(rt) { // right is typed
-								checkOrConvertType(store, last, &n.Left, rt, false)
+								checkOrConvertType(store, last, n, &n.Left, rt, false)
 							} else {
 								if shouldSwapOnSpecificity(lt, rt) {
 									checkUntypedShiftExpr(n.Right)
@@ -1165,10 +1165,10 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 						}
 					} else if lcx.T == nil { // LHS is nil.
 						// convert n.Left to typed-nil type.
-						checkOrConvertType(store, last, &n.Left, rt, false)
+						checkOrConvertType(store, last, n, &n.Left, rt, false)
 					} else {
 						if isUntyped(rt) {
-							checkOrConvertType(store, last, &n.Right, lt, false)
+							checkOrConvertType(store, last, n, &n.Right, lt, false)
 						}
 					}
 				} else if ric { // right is const, left is not
@@ -1186,7 +1186,7 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 							// convert n.Left to (gno) pt type,
 							ln := Expr(Call(pt.String(), n.Left))
 							// convert n.Right to pt type,
-							checkOrConvertType(store, last, &n.Right, pt, false)
+							checkOrConvertType(store, last, n, &n.Right, pt, false)
 							// and convert result back.
 							tx := constType(n, lnt)
 							// reset/create n2 to preprocess left child.
@@ -1212,7 +1212,7 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 							}
 							// both untyped, e.g. 1<<s != 1.0
 							if !isUntyped(lt) { // left is typed
-								checkOrConvertType(store, last, &n.Right, lt, false)
+								checkOrConvertType(store, last, n, &n.Right, lt, false)
 							} else { // if one side is untyped shift expression, check type with lower specificity
 								if shouldSwapOnSpecificity(lt, rt) {
 									checkUntypedShiftExpr(n.Right)
@@ -1223,10 +1223,10 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 						}
 					} else if rcx.T == nil { // RHS is nil
 						// refer to tests/files/types/eql_0f20.gno
-						checkOrConvertType(store, last, &n.Right, lt, false)
+						checkOrConvertType(store, last, n, &n.Right, lt, false)
 					} else { // left is not const, right is typed const
 						if isUntyped(lt) {
-							checkOrConvertType(store, last, &n.Left, rt, false)
+							checkOrConvertType(store, last, n, &n.Left, rt, false)
 						}
 					}
 				} else {
@@ -1258,7 +1258,7 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 									rnt.String()))
 							}
 							// check assignable, if pass, convert right to gno first
-							assertAssignableTo(lpt, rpt, false) // both primitive types
+							assertAssignableTo(n, lpt, rpt, false) // both primitive types
 							rn = Expr(Call(rpt.String(), n.Right))
 						} else { // rt not native
 							panic(fmt.Sprintf(
@@ -1296,7 +1296,7 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 						if isShift {
 							panic("should not happen")
 						} else {
-							checkOrConvertType(store, last, &n.Left, pt, false)
+							checkOrConvertType(store, last, n, &n.Left, pt, false)
 						}
 						// and convert result back.
 						tx := constType(n, rnt)
@@ -1324,18 +1324,18 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 										lt.TypeID(), n.Op, rt.TypeID()))
 								}
 								// convert untyped to typed
-								checkOrConvertType(store, last, &n.Left, defaultTypeOf(lt), false)
-								checkOrConvertType(store, last, &n.Right, defaultTypeOf(rt), false)
+								checkOrConvertType(store, last, n, &n.Left, defaultTypeOf(lt), false)
+								checkOrConvertType(store, last, n, &n.Right, defaultTypeOf(rt), false)
 							} else { // left untyped, right typed
-								checkOrConvertType(store, last, &n.Left, rt, false)
+								checkOrConvertType(store, last, n, &n.Left, rt, false)
 							}
 						} else if riu { // left typed, right untyped
-							checkOrConvertType(store, last, &n.Right, lt, false)
+							checkOrConvertType(store, last, n, &n.Right, lt, false)
 						} else { // both typed, refer to 0a1g.gno
 							if !shouldSwapOnSpecificity(lt, rt) {
-								checkOrConvertType(store, last, &n.Left, rt, false)
+								checkOrConvertType(store, last, n, &n.Left, rt, false)
 							} else {
-								checkOrConvertType(store, last, &n.Right, lt, false)
+								checkOrConvertType(store, last, n, &n.Right, lt, false)
 							}
 						}
 					}
@@ -1373,7 +1373,7 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 								}
 							}
 							if isNumeric(at) {
-								convertConst(store, last, arg0, ct)
+								convertConst(store, last, n, arg0, ct)
 								constConverted = true
 							}
 						} else if ct.Kind() == SliceKind {
@@ -1385,7 +1385,7 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 						// (const) untyped decimal -> float64.
 						// (const) untyped bigint -> int.
 						if !constConverted {
-							convertConst(store, last, arg0, nil)
+							convertConst(store, last, n, arg0, nil)
 						}
 						// evaluate the new expression.
 						cx := evalConst(store, last, n)
@@ -1397,15 +1397,15 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 						if isUntyped(at) {
 							switch arg0.Op {
 							case EQL, NEQ, LSS, GTR, LEQ, GEQ:
-								assertAssignableTo(at, ct, false)
+								assertAssignableTo(n, at, ct, false)
 								break
 							default:
-								checkOrConvertType(store, last, &n.Args[0], ct, false)
+								checkOrConvertType(store, last, n, &n.Args[0], ct, false)
 							}
 						}
 					case *UnaryExpr:
 						if isUntyped(at) {
-							checkOrConvertType(store, last, &n.Args[0], ct, false)
+							checkOrConvertType(store, last, n, &n.Args[0], ct, false)
 						}
 					default:
 						// do nothing
@@ -1549,7 +1549,7 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 					panic("should not happen")
 				}
 				// Specify function param/result generics.
-				sft := ft.Specify(store, argTVs, isVarg)
+				sft := ft.Specify(store, n, argTVs, isVarg)
 				spts := sft.Params
 				srts := FieldTypeList(sft.Results).Types()
 				// If generics were specified, override attr
@@ -1575,12 +1575,12 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 					for i, tv := range argTVs {
 						if hasVarg {
 							if (len(spts) - 1) <= i {
-								assertAssignableTo(tv.T, spts[len(spts)-1].Type.Elem(), true)
+								assertAssignableTo(n, tv.T, spts[len(spts)-1].Type.Elem(), true)
 							} else {
-								assertAssignableTo(tv.T, spts[i].Type, true)
+								assertAssignableTo(n, tv.T, spts[i].Type, true)
 							}
 						} else {
-							assertAssignableTo(tv.T, spts[i].Type, true)
+							assertAssignableTo(n, tv.T, spts[i].Type, true)
 						}
 					}
 				} else {
@@ -1591,16 +1591,16 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 									if len(spts) <= i {
 										panic("expected final vargs slice but got many")
 									}
-									checkOrConvertType(store, last, &n.Args[i], spts[i].Type, true)
+									checkOrConvertType(store, last, n, &n.Args[i], spts[i].Type, true)
 								} else {
-									checkOrConvertType(store, last, &n.Args[i],
+									checkOrConvertType(store, last, n, &n.Args[i],
 										spts[len(spts)-1].Type.Elem(), true)
 								}
 							} else {
-								checkOrConvertType(store, last, &n.Args[i], spts[i].Type, true)
+								checkOrConvertType(store, last, n, &n.Args[i], spts[i].Type, true)
 							}
 						} else {
-							checkOrConvertType(store, last, &n.Args[i], spts[i].Type, true)
+							checkOrConvertType(store, last, n, &n.Args[i], spts[i].Type, true)
 						}
 					}
 				}
@@ -1621,10 +1621,10 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 				case StringKind, ArrayKind, SliceKind:
 					// Replace const index with int *ConstExpr,
 					// or if not const, assert integer type..
-					checkOrConvertIntegerKind(store, last, n.Index)
+					checkOrConvertIntegerKind(store, last, n, n.Index)
 				case MapKind:
 					mt := baseOf(gnoTypeOf(store, dt)).(*MapType)
-					checkOrConvertType(store, last, &n.Index, mt.Key, false)
+					checkOrConvertType(store, last, n, &n.Index, mt.Key, false)
 				default:
 					panic(fmt.Sprintf(
 						"unexpected index base kind for type %s",
@@ -1635,15 +1635,15 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 			case *SliceExpr:
 				// Replace const L/H/M with int *ConstExpr,
 				// or if not const, assert integer type..
-				checkOrConvertIntegerKind(store, last, n.Low)
-				checkOrConvertIntegerKind(store, last, n.High)
-				checkOrConvertIntegerKind(store, last, n.Max)
+				checkOrConvertIntegerKind(store, last, n, n.Low)
+				checkOrConvertIntegerKind(store, last, n, n.High)
+				checkOrConvertIntegerKind(store, last, n, n.Max)
 
 				// if n.X is untyped, convert to corresponding type
 				t := evalStaticTypeOf(store, last, n.X)
 				if isUntyped(t) {
 					dt := defaultTypeOf(t)
-					checkOrConvertType(store, last, &n.X, dt, false)
+					checkOrConvertType(store, last, n, &n.X, dt, false)
 				}
 
 			// TRANS_LEAVE -----------------------
@@ -1722,28 +1722,28 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 							key := n.Elts[i].Key.(*NameExpr).Name
 							path := cclt.GetPathForName(key)
 							ft := cclt.GetStaticTypeOfAt(path)
-							checkOrConvertType(store, last, &n.Elts[i].Value, ft, false)
+							checkOrConvertType(store, last, n, &n.Elts[i].Value, ft, false)
 						}
 					} else {
 						for i := 0; i < len(n.Elts); i++ {
 							ft := cclt.Fields[i].Type
-							checkOrConvertType(store, last, &n.Elts[i].Value, ft, false)
+							checkOrConvertType(store, last, n, &n.Elts[i].Value, ft, false)
 						}
 					}
 				case *ArrayType:
 					for i := 0; i < len(n.Elts); i++ {
-						convertType(store, last, &n.Elts[i].Key, IntType)
-						checkOrConvertType(store, last, &n.Elts[i].Value, cclt.Elt, false)
+						convertType(store, last, n, &n.Elts[i].Key, IntType)
+						checkOrConvertType(store, last, n, &n.Elts[i].Value, cclt.Elt, false)
 					}
 				case *SliceType:
 					for i := 0; i < len(n.Elts); i++ {
-						convertType(store, last, &n.Elts[i].Key, IntType)
-						checkOrConvertType(store, last, &n.Elts[i].Value, cclt.Elt, false)
+						convertType(store, last, n, &n.Elts[i].Key, IntType)
+						checkOrConvertType(store, last, n, &n.Elts[i].Value, cclt.Elt, false)
 					}
 				case *MapType:
 					for i := 0; i < len(n.Elts); i++ {
-						checkOrConvertType(store, last, &n.Elts[i].Key, cclt.Key, false)
-						checkOrConvertType(store, last, &n.Elts[i].Value, cclt.Value, false)
+						checkOrConvertType(store, last, n, &n.Elts[i].Key, cclt.Key, false)
+						checkOrConvertType(store, last, n, &n.Elts[i].Value, cclt.Value, false)
 					}
 				case *NativeType:
 					clt = cclt.GnoType(store)
@@ -1943,7 +1943,7 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 			// TRANS_LEAVE -----------------------
 			case *FieldTypeExpr:
 				// Replace const Tag with default *ConstExpr.
-				convertIfConst(store, last, n.Tag)
+				convertIfConst(store, last, n, n.Tag)
 
 			// TRANS_LEAVE -----------------------
 			case *ArrayTypeExpr:
@@ -1952,7 +1952,7 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 				} else {
 					// Replace const Len with int *ConstExpr.
 					cx := evalConst(store, last, n.Len)
-					convertConst(store, last, cx, IntType)
+					convertConst(store, last, n, cx, IntType)
 					n.Len = cx
 				}
 				// NOTE: For all TypeExprs, the node is not replaced
@@ -1993,7 +1993,7 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 					// Rhs consts become default *ConstExprs.
 					for _, rx := range n.Rhs {
 						// NOTE: does nothing if rx is "nil".
-						convertIfConst(store, last, rx)
+						convertIfConst(store, last, n, rx)
 					}
 
 					nameExprs := make(NameExprs, len(n.Lhs))
@@ -2001,7 +2001,7 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 						nameExprs[i] = *n.Lhs[i].(*NameExpr)
 					}
 
-					defineOrDecl(store, last, false, nameExprs, nil, n.Rhs)
+					defineOrDecl(store, last, n, false, nameExprs, nil, n.Rhs)
 				} else { // ASSIGN, or assignment operation (+=, -=, <<=, etc.)
 					// NOTE: Keep in sync with DEFINE above.
 					if len(n.Lhs) > len(n.Rhs) {
@@ -2090,11 +2090,11 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 					} else { // len(Lhs) == len(Rhs)
 						if n.Op == SHL_ASSIGN || n.Op == SHR_ASSIGN {
 							// Special case if shift assign <<= or >>=.
-							convertType(store, last, &n.Rhs[0], UintType)
+							convertType(store, last, n, &n.Rhs[0], UintType)
 						} else if n.Op == ADD_ASSIGN || n.Op == SUB_ASSIGN || n.Op == MUL_ASSIGN || n.Op == QUO_ASSIGN || n.Op == REM_ASSIGN {
 							// e.g. a += b, single value for lhs and rhs,
 							lt := evalStaticTypeOf(store, last, n.Lhs[0])
-							checkOrConvertType(store, last, &n.Rhs[0], lt, true)
+							checkOrConvertType(store, last, n, &n.Rhs[0], lt, true)
 						} else { // all else, like BAND_ASSIGN, etc
 							// General case: a, b = x, y.
 							for i, lx := range n.Lhs {
@@ -2104,7 +2104,7 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 								}
 
 								// if lt is interface, nothing will happen
-								checkOrConvertType(store, last, &n.Rhs[i], lt, true)
+								checkOrConvertType(store, last, n, &n.Rhs[i], lt, true)
 							}
 						}
 					}
@@ -2181,12 +2181,12 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 			// TRANS_LEAVE -----------------------
 			case *ForStmt:
 				// Cond consts become bool *ConstExprs.
-				checkOrConvertBoolKind(store, last, n.Cond)
+				checkOrConvertBoolKind(store, last, n, n.Cond)
 
 			// TRANS_LEAVE -----------------------
 			case *IfStmt:
 				// Cond consts become bool *ConstExprs.
-				checkOrConvertBoolKind(store, last, n.Cond)
+				checkOrConvertBoolKind(store, last, n, n.Cond)
 
 			// TRANS_LEAVE -----------------------
 			case *RangeStmt:
@@ -2242,7 +2242,7 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 							// XXX how to deal?
 							panic("not yet implemented")
 						} else {
-							checkOrConvertType(store, last, &n.Results[i], rt, false)
+							checkOrConvertType(store, last, n, &n.Results[i], rt, false)
 						}
 					}
 				}
@@ -2250,7 +2250,7 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 			// TRANS_LEAVE -----------------------
 			case *SendStmt:
 				// Value consts become default *ConstExprs.
-				checkOrConvertType(store, last, &n.Value, nil, false)
+				checkOrConvertType(store, last, n, &n.Value, nil, false)
 
 			// TRANS_LEAVE -----------------------
 			case *SelectCaseStmt:
@@ -2303,7 +2303,7 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 					// runDeclaration(), as this uses OpStaticTypeOf.
 				}
 
-				defineOrDecl(store, last, n.Const, n.NameExprs, n.Type, n.Values)
+				defineOrDecl(store, last, n, n.Const, n.NameExprs, n.Type, n.Values)
 
 				// TODO make note of constance in static block for
 				// future use, or consider "const paths".  set as
@@ -2383,6 +2383,7 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 func defineOrDecl(
 	store Store,
 	bn BlockNode,
+	n Node,
 	isConst bool,
 	nameExprs []NameExpr,
 	typeExpr Expr,
@@ -2399,9 +2400,9 @@ func defineOrDecl(
 	tvs := make([]TypedValue, numNames)
 
 	if numVals == 1 && numNames > 1 {
-		parseMultipleAssignFromOneExpr(sts, tvs, store, bn, nameExprs, typeExpr, valueExprs[0])
+		parseMultipleAssignFromOneExpr(store, bn, n, sts, tvs, nameExprs, typeExpr, valueExprs[0])
 	} else {
-		parseAssignFromExprList(sts, tvs, store, bn, isConst, nameExprs, typeExpr, valueExprs)
+		parseAssignFromExprList(store, bn, n, sts, tvs, isConst, nameExprs, typeExpr, valueExprs)
 	}
 
 	node := skipFile(bn)
@@ -2420,10 +2421,11 @@ func defineOrDecl(
 // parseAssignFromExprList parses assignment to multiple variables from a list of expressions.
 // This function will alter the value of sts, tvs.
 func parseAssignFromExprList(
-	sts []Type,
-	tvs []TypedValue,
 	store Store,
 	bn BlockNode,
+	n Node,
+	sts []Type,
+	tvs []TypedValue,
 	isConst bool,
 	nameExprs []NameExpr,
 	typeExpr Expr,
@@ -2450,7 +2452,7 @@ func parseAssignFromExprList(
 		}
 		// Convert if const to nt.
 		for i := range valueExprs {
-			checkOrConvertType(store, bn, &valueExprs[i], nt, false)
+			checkOrConvertType(store, bn, n, &valueExprs[i], nt, false)
 		}
 	} else if isConst {
 		// Derive static type from values.
@@ -2462,10 +2464,10 @@ func parseAssignFromExprList(
 		// Convert n.Value to default type.
 		for i, vx := range valueExprs {
 			if cx, ok := vx.(*ConstExpr); ok {
-				convertConst(store, bn, cx, nil)
+				convertConst(store, bn, n, cx, nil)
 				// convertIfConst(store, last, vx)
 			} else {
-				checkOrConvertType(store, bn, &vx, nil, false)
+				checkOrConvertType(store, bn, n, &vx, nil, false)
 			}
 			vt := evalStaticTypeOf(store, bn, vx)
 			sts[i] = vt
@@ -2506,10 +2508,11 @@ func parseAssignFromExprList(
 // - a, b := n.(T)
 // - a, b := n[i], where n is a map
 func parseMultipleAssignFromOneExpr(
-	sts []Type,
-	tvs []TypedValue,
 	store Store,
 	bn BlockNode,
+	n Node,
+	sts []Type,
+	tvs []TypedValue,
 	nameExprs []NameExpr,
 	typeExpr Expr,
 	valueExpr Expr,
@@ -2567,7 +2570,7 @@ func parseMultipleAssignFromOneExpr(
 		if st != nil {
 			tt := tuple.Elts[i]
 
-			if checkAssignableTo(tt, st, false) != nil {
+			if checkAssignableTo(n, tt, st, false) != nil {
 				panic(
 					fmt.Sprintf(
 						"cannot use %v (value of type %s) as %s value in assignment",
@@ -3491,14 +3494,14 @@ func isConstType(x Expr) bool {
 }
 
 // check before convert type
-func checkOrConvertType(store Store, last BlockNode, x *Expr, t Type, autoNative bool) {
+func checkOrConvertType(store Store, last BlockNode, n Node, x *Expr, t Type, autoNative bool) {
 	if debug {
 		debug.Printf("checkOrConvertType, *x: %v:, t:%v \n", *x, t)
 	}
 	if cx, ok := (*x).(*ConstExpr); ok {
 		if _, ok := t.(*NativeType); !ok { // not native type, refer to time4_native.gno.
 			// e.g. int(1) == int8(1)
-			assertAssignableTo(cx.T, t, autoNative)
+			assertAssignableTo(n, cx.T, t, autoNative)
 		}
 	} else if bx, ok := (*x).(*BinaryExpr); ok && (bx.Op == SHL || bx.Op == SHR) {
 		xt := evalStaticTypeOf(store, last, *x)
@@ -3507,22 +3510,22 @@ func checkOrConvertType(store Store, last BlockNode, x *Expr, t Type, autoNative
 		}
 		if isUntyped(xt) {
 			// check assignable first, see: types/shift_b6.gno
-			assertAssignableTo(xt, t, autoNative)
+			assertAssignableTo(n, xt, t, autoNative)
 
 			if t == nil || t.Kind() == InterfaceKind {
 				t = defaultTypeOf(xt)
 			}
 
 			bx.assertShiftExprCompatible2(t)
-			checkOrConvertType(store, last, &bx.Left, t, autoNative)
+			checkOrConvertType(store, last, n, &bx.Left, t, autoNative)
 		} else {
-			assertAssignableTo(xt, t, autoNative)
+			assertAssignableTo(n, xt, t, autoNative)
 		}
 		return
 	} else if *x != nil {
 		xt := evalStaticTypeOf(store, last, *x)
 		if t != nil {
-			assertAssignableTo(xt, t, autoNative)
+			assertAssignableTo(n, xt, t, autoNative)
 		}
 		if isUntyped(xt) {
 			// Push type into expr if qualifying binary expr.
@@ -3534,8 +3537,8 @@ func checkOrConvertType(store Store, last BlockNode, x *Expr, t Type, autoNative
 					rt := evalStaticTypeOf(store, last, bx.Right)
 					if t != nil {
 						// push t into bx.Left and bx.Right
-						checkOrConvertType(store, last, &bx.Left, t, autoNative)
-						checkOrConvertType(store, last, &bx.Right, t, autoNative)
+						checkOrConvertType(store, last, n, &bx.Left, t, autoNative)
+						checkOrConvertType(store, last, n, &bx.Right, t, autoNative)
 						return
 					} else {
 						if shouldSwapOnSpecificity(lt, rt) {
@@ -3546,11 +3549,11 @@ func checkOrConvertType(store Store, last BlockNode, x *Expr, t Type, autoNative
 							// without a specific context type, '1.0<<s' is checked against
 							// its default type, the BigDecKind, will trigger assertion failure.
 							// so here in checkOrConvertType, shift expression is "finally" checked.
-							checkOrConvertType(store, last, &bx.Left, lt, autoNative)
-							checkOrConvertType(store, last, &bx.Right, lt, autoNative)
+							checkOrConvertType(store, last, n, &bx.Left, lt, autoNative)
+							checkOrConvertType(store, last, n, &bx.Right, lt, autoNative)
 						} else {
-							checkOrConvertType(store, last, &bx.Left, rt, autoNative)
-							checkOrConvertType(store, last, &bx.Right, rt, autoNative)
+							checkOrConvertType(store, last, n, &bx.Left, rt, autoNative)
+							checkOrConvertType(store, last, n, &bx.Right, rt, autoNative)
 						}
 					}
 					return
@@ -3558,11 +3561,11 @@ func checkOrConvertType(store Store, last BlockNode, x *Expr, t Type, autoNative
 					lt := evalStaticTypeOf(store, last, bx.Left)
 					rt := evalStaticTypeOf(store, last, bx.Right)
 					if shouldSwapOnSpecificity(lt, rt) {
-						checkOrConvertType(store, last, &bx.Left, lt, autoNative)
-						checkOrConvertType(store, last, &bx.Right, lt, autoNative)
+						checkOrConvertType(store, last, n, &bx.Left, lt, autoNative)
+						checkOrConvertType(store, last, n, &bx.Right, lt, autoNative)
 					} else {
-						checkOrConvertType(store, last, &bx.Left, rt, autoNative)
-						checkOrConvertType(store, last, &bx.Right, rt, autoNative)
+						checkOrConvertType(store, last, n, &bx.Left, rt, autoNative)
+						checkOrConvertType(store, last, n, &bx.Right, rt, autoNative)
 					}
 				default:
 					// do nothing
@@ -3570,18 +3573,18 @@ func checkOrConvertType(store Store, last BlockNode, x *Expr, t Type, autoNative
 			} else if ux, ok := (*x).(*UnaryExpr); ok {
 				xt := evalStaticTypeOf(store, last, *x)
 				// check assignable first
-				assertAssignableTo(xt, t, autoNative)
+				assertAssignableTo(n, xt, t, autoNative)
 
 				if t == nil || t.Kind() == InterfaceKind {
 					t = defaultTypeOf(xt)
 				}
-				checkOrConvertType(store, last, &ux.X, t, autoNative)
+				checkOrConvertType(store, last, n, &ux.X, t, autoNative)
 				return
 			}
 		}
 	}
 	// convert recursively
-	convertType(store, last, x, t)
+	convertType(store, last, n, x, t)
 }
 
 // 1. convert x to t if x is *ConstExpr.
@@ -3590,12 +3593,12 @@ func checkOrConvertType(store Store, last BlockNode, x *Expr, t Type, autoNative
 // for native function calls, where gno values are
 // automatically converted to native go types.
 // NOTE: also see checkOrConvertIntegerKind()
-func convertType(store Store, last BlockNode, x *Expr, t Type) {
+func convertType(store Store, last BlockNode, n Node, x *Expr, t Type) {
 	if debug {
 		debug.Printf("convertType, *x: %v:, t:%v \n", *x, t)
 	}
 	if cx, ok := (*x).(*ConstExpr); ok {
-		convertConst(store, last, cx, t)
+		convertConst(store, last, n, cx, t)
 	} else if *x != nil {
 		xt := evalStaticTypeOf(store, last, *x)
 		if isUntyped(xt) {
@@ -3658,16 +3661,16 @@ func isNamedConversion(xt, t Type) bool {
 }
 
 // like checkOrConvertType(last, x, nil)
-func convertIfConst(store Store, last BlockNode, x Expr) {
+func convertIfConst(store Store, last BlockNode, n Node, x Expr) {
 	if cx, ok := x.(*ConstExpr); ok {
-		convertConst(store, last, cx, nil)
+		convertConst(store, last, n, cx, nil)
 	}
 }
 
-func convertConst(store Store, last BlockNode, cx *ConstExpr, t Type) {
+func convertConst(store Store, last BlockNode, n Node, cx *ConstExpr, t Type) {
 	if t != nil && t.Kind() == InterfaceKind {
 		if cx.T != nil {
-			assertAssignableTo(cx.T, t, false)
+			assertAssignableTo(n, cx.T, t, false)
 		}
 		t = nil // signifies to convert to default type.
 	}
@@ -3980,9 +3983,9 @@ func findUndefined2(store Store, last BlockNode, x Expr, t Type) (un Name) {
 }
 
 // like checkOrConvertType() but for any typed bool kind.
-func checkOrConvertBoolKind(store Store, last BlockNode, x Expr) {
+func checkOrConvertBoolKind(store Store, last BlockNode, n Node, x Expr) {
 	if cx, ok := x.(*ConstExpr); ok {
-		convertConst(store, last, cx, BoolType)
+		convertConst(store, last, n, cx, BoolType)
 	} else if x != nil {
 		xt := evalStaticTypeOf(store, last, x)
 		checkBoolKind(xt)
@@ -4002,9 +4005,9 @@ func checkBoolKind(xt Type) {
 }
 
 // like checkOrConvertType() but for any typed integer kind.
-func checkOrConvertIntegerKind(store Store, last BlockNode, x Expr) {
+func checkOrConvertIntegerKind(store Store, last BlockNode, n Node, x Expr) {
 	if cx, ok := x.(*ConstExpr); ok {
-		convertConst(store, last, cx, IntType)
+		convertConst(store, last, n, cx, IntType)
 	} else if x != nil {
 		xt := evalStaticTypeOf(store, last, x)
 		checkIntegerKind(xt)
diff --git a/gnovm/pkg/gnolang/type_check.go b/gnovm/pkg/gnolang/type_check.go
index 95b1c54ae4b..70166116fcc 100644
--- a/gnovm/pkg/gnolang/type_check.go
+++ b/gnovm/pkg/gnolang/type_check.go
@@ -208,8 +208,8 @@ func checkSame(at, bt Type, msg string) error {
 	return nil
 }
 
-func assertAssignableTo(xt, dt Type, autoNative bool) {
-	err := checkAssignableTo(xt, dt, autoNative)
+func assertAssignableTo(n Node, xt, dt Type, autoNative bool) {
+	err := checkAssignableTo(n, xt, dt, autoNative)
 	if err != nil {
 		panic(err.Error())
 	}
@@ -282,7 +282,7 @@ func checkValDefineMismatch(n Node) {
 // Assert that xt can be assigned as dt (dest type).
 // If autoNative is true, a broad range of xt can match against
 // a target native dt type, if and only if dt is a native type.
-func checkAssignableTo(xt, dt Type, autoNative bool) error {
+func checkAssignableTo(n Node, xt, dt Type, autoNative bool) error {
 	if debug {
 		debug.Printf("checkAssignableTo, xt: %v dt: %v \n", xt, dt)
 	}
@@ -292,7 +292,20 @@ func checkAssignableTo(xt, dt Type, autoNative bool) error {
 			return nil
 		}
 		if !maybeNil(dt) {
-			panic(fmt.Sprintf("invalid operation, nil can not be compared to %v", dt))
+			switch n := n.(type) {
+			case *ValueDecl:
+				panic(fmt.Sprintf("cannot use nil as %v value in variable declaration", dt))
+			case *AssignStmt:
+				panic(fmt.Sprintf("cannot use nil as %v value in assignment", dt))
+			case *CompositeLitExpr:
+				panic(fmt.Sprintf("cannot use nil as %v value in array, slice literal or map literal", dt))
+			case *CallExpr:
+				panic(fmt.Sprintf("cannot use nil as %v value in argument to %v", dt, n.Func))
+			case *BinaryExpr:
+				panic(fmt.Sprintf("invalid operation: %v (mismatched types %v and untyped nil)", n, dt))
+			default:
+				panic(fmt.Sprintf("cannot use nil as %v value", dt))
+			}
 		}
 		return nil
 	} else if dt == nil { // _ = xxx, assign8.gno, 0f31. else cases?
@@ -504,7 +517,7 @@ func checkAssignableTo(xt, dt Type, autoNative bool) error {
 		}
 	case *PointerType: // case 4 from here on
 		if pt, ok := xt.(*PointerType); ok {
-			return checkAssignableTo(pt.Elt, cdt.Elt, false)
+			return checkAssignableTo(n, pt.Elt, cdt.Elt, false)
 		}
 	case *ArrayType:
 		if at, ok := xt.(*ArrayType); ok {
@@ -526,7 +539,7 @@ func checkAssignableTo(xt, dt Type, autoNative bool) error {
 	case *SliceType:
 		if st, ok := xt.(*SliceType); ok {
 			if cdt.Vrd {
-				return checkAssignableTo(st.Elt, cdt.Elt, false)
+				return checkAssignableTo(n, st.Elt, cdt.Elt, false)
 			} else {
 				err := checkSame(st.Elt, cdt.Elt, "")
 				if err != nil {
@@ -634,7 +647,7 @@ func (x *BinaryExpr) assertShiftExprCompatible1(store Store, last BlockNode, lt,
 		if lt == UntypedBigdecType {
 			// 1.0 << 1
 			if lic && ric {
-				convertConst(store, last, lcx, UntypedBigintType)
+				convertConst(store, last, x, lcx, UntypedBigintType)
 				return
 			}
 		}
@@ -697,11 +710,11 @@ func (x *BinaryExpr) AssertCompatible(lt, rt Type) {
 		case EQL, NEQ:
 			assertComparable(xt, dt)
 			if !isUntyped(xt) && !isUntyped(dt) {
-				assertAssignableTo(xt, dt, false)
+				assertAssignableTo(x, xt, dt, false)
 			}
 		case LSS, LEQ, GTR, GEQ:
 			if checker, ok := binaryChecker[x.Op]; ok {
-				x.checkCompatibility(xt, dt, checker, x.Op.TokenString())
+				x.checkCompatibility(x, xt, dt, checker, x.Op.TokenString())
 			} else {
 				panic(fmt.Sprintf("checker for %s does not exist", x.Op))
 			}
@@ -710,7 +723,7 @@ func (x *BinaryExpr) AssertCompatible(lt, rt Type) {
 		}
 	} else {
 		if checker, ok := binaryChecker[x.Op]; ok {
-			x.checkCompatibility(xt, dt, checker, x.Op.TokenString())
+			x.checkCompatibility(x, xt, dt, checker, x.Op.TokenString())
 		} else {
 			panic(fmt.Sprintf("checker for %s does not exist", x.Op))
 		}
@@ -738,14 +751,14 @@ func (x *BinaryExpr) AssertCompatible(lt, rt Type) {
 // The function checkOrConvertType will be invoked after this check.
 // NOTE: dt is established based on a specificity check between xt and dt,
 // confirming dt as the appropriate destination type for this context.
-func (x *BinaryExpr) checkCompatibility(xt, dt Type, checker func(t Type) bool, OpStr string) {
+func (x *BinaryExpr) checkCompatibility(n Node, xt, dt Type, checker func(t Type) bool, OpStr string) {
 	if !checker(dt) {
 		panic(fmt.Sprintf("operator %s not defined on: %v", OpStr, kindString(dt)))
 	}
 
 	// if both typed
 	if !isUntyped(xt) && !isUntyped(dt) {
-		err := checkAssignableTo(xt, dt, false)
+		err := checkAssignableTo(n, xt, dt, false)
 		if err != nil {
 			panic(fmt.Sprintf("invalid operation: mismatched types %v and %v", xt, dt))
 		}
@@ -810,19 +823,19 @@ func (x *RangeStmt) AssertCompatible(store Store, last BlockNode) {
 	xt := evalStaticTypeOf(store, last, x.X)
 	switch cxt := xt.(type) {
 	case *MapType:
-		assertAssignableTo(cxt.Key, kt, false)
+		assertAssignableTo(x, cxt.Key, kt, false)
 		if vt != nil {
-			assertAssignableTo(cxt.Value, vt, false)
+			assertAssignableTo(x, cxt.Value, vt, false)
 		}
 	case *SliceType:
 		assertIndexTypeIsInt(kt)
 		if vt != nil {
-			assertAssignableTo(cxt.Elt, vt, false)
+			assertAssignableTo(x, cxt.Elt, vt, false)
 		}
 	case *ArrayType:
 		assertIndexTypeIsInt(kt)
 		if vt != nil {
-			assertAssignableTo(cxt.Elt, vt, false)
+			assertAssignableTo(x, cxt.Elt, vt, false)
 		}
 	case PrimitiveType:
 		if cxt.Kind() == StringKind {
@@ -862,7 +875,7 @@ func (x *AssignStmt) AssertCompatible(store Store, last BlockNode) {
 						assertValidAssignLhs(store, last, lx)
 						if !isBlankIdentifier(lx) {
 							lxt := evalStaticTypeOf(store, last, lx)
-							assertAssignableTo(cft.Results[i].Type, lxt, false)
+							assertAssignableTo(x, cft.Results[i].Type, lxt, false)
 						}
 					}
 				}
@@ -877,7 +890,7 @@ func (x *AssignStmt) AssertCompatible(store Store, last BlockNode) {
 					if !isBlankIdentifier(x.Lhs[0]) { // see composite3.gno
 						dt := evalStaticTypeOf(store, last, x.Lhs[0])
 						ift := evalStaticTypeOf(store, last, cx)
-						assertAssignableTo(ift, dt, false)
+						assertAssignableTo(x, ift, dt, false)
 					}
 					// check second value
 					assertValidAssignLhs(store, last, x.Lhs[1])
@@ -900,12 +913,12 @@ func (x *AssignStmt) AssertCompatible(store Store, last BlockNode) {
 						if _, ok := cx.X.(*NameExpr); ok {
 							rt := evalStaticTypeOf(store, last, cx.X)
 							if mt, ok := rt.(*MapType); ok {
-								assertAssignableTo(mt.Value, lt, false)
+								assertAssignableTo(x, mt.Value, lt, false)
 							}
 						} else if _, ok := cx.X.(*CompositeLitExpr); ok {
 							cpt := evalStaticTypeOf(store, last, cx.X)
 							if mt, ok := cpt.(*MapType); ok {
-								assertAssignableTo(mt.Value, lt, false)
+								assertAssignableTo(x, mt.Value, lt, false)
 							} else {
 								panic("should not happen")
 							}
diff --git a/gnovm/pkg/gnolang/type_check_test.go b/gnovm/pkg/gnolang/type_check_test.go
index 4b738961e0f..7fddf2c65d0 100644
--- a/gnovm/pkg/gnolang/type_check_test.go
+++ b/gnovm/pkg/gnolang/type_check_test.go
@@ -51,7 +51,7 @@ func TestCheckAssignableTo(t *testing.T) {
 					}
 				}()
 			}
-			checkAssignableTo(tt.xt, tt.dt, tt.autoNative)
+			checkAssignableTo(nil, tt.xt, tt.dt, tt.autoNative)
 		})
 	}
 }
diff --git a/gnovm/pkg/gnolang/types.go b/gnovm/pkg/gnolang/types.go
index bfc7cc31584..18774fcc462 100644
--- a/gnovm/pkg/gnolang/types.go
+++ b/gnovm/pkg/gnolang/types.go
@@ -1181,7 +1181,7 @@ func (ft *FuncType) UnboundType(rft FieldType) *FuncType {
 // NOTE: if ft.HasVarg() and !isVarg, argTVs[len(ft.Params):]
 // are ignored (since they are of the same type as
 // argTVs[len(ft.Params)-1]).
-func (ft *FuncType) Specify(store Store, argTVs []TypedValue, isVarg bool) *FuncType {
+func (ft *FuncType) Specify(store Store, n Node, argTVs []TypedValue, isVarg bool) *FuncType {
 	hasGenericParams := false
 	hasGenericResults := false
 	for _, pf := range ft.Params {
@@ -1248,9 +1248,9 @@ func (ft *FuncType) Specify(store Store, argTVs []TypedValue, isVarg bool) *Func
 	for i, pf := range ft.Params {
 		arg := &argTVs[i]
 		if arg.T.Kind() == TypeKind {
-			specifyType(store, lookup, pf.Type, arg.T, arg.GetType())
+			specifyType(store, n, lookup, pf.Type, arg.T, arg.GetType())
 		} else {
-			specifyType(store, lookup, pf.Type, arg.T, nil)
+			specifyType(store, n, lookup, pf.Type, arg.T, nil)
 		}
 	}
 	// apply specifics to generic params and results.
@@ -2427,7 +2427,7 @@ func IsImplementedBy(it Type, ot Type) bool {
 // specTypeval is Type if spec is TypeKind.
 // NOTE: type-checking isn't strictly necessary here, as the resulting lookup
 // map gets applied to produce the ultimate param and result types.
-func specifyType(store Store, lookup map[Name]Type, tmpl Type, spec Type, specTypeval Type) {
+func specifyType(store Store, n Node, lookup map[Name]Type, tmpl Type, spec Type, specTypeval Type) {
 	if isGeneric(spec) {
 		panic("spec must not be generic")
 	}
@@ -2441,11 +2441,11 @@ func specifyType(store Store, lookup map[Name]Type, tmpl Type, spec Type, specTy
 	case *PointerType:
 		switch pt := baseOf(spec).(type) {
 		case *PointerType:
-			specifyType(store, lookup, ct.Elt, pt.Elt, nil)
+			specifyType(store, n, lookup, ct.Elt, pt.Elt, nil)
 		case *NativeType:
 			// NOTE: see note about type-checking.
 			et := pt.Elem()
-			specifyType(store, lookup, ct.Elt, et, nil)
+			specifyType(store, n, lookup, ct.Elt, et, nil)
 		default:
 			panic(fmt.Sprintf(
 				"expected pointer kind but got %s",
@@ -2454,11 +2454,11 @@ func specifyType(store Store, lookup map[Name]Type, tmpl Type, spec Type, specTy
 	case *ArrayType:
 		switch at := baseOf(spec).(type) {
 		case *ArrayType:
-			specifyType(store, lookup, ct.Elt, at.Elt, nil)
+			specifyType(store, n, lookup, ct.Elt, at.Elt, nil)
 		case *NativeType:
 			// NOTE: see note about type-checking.
 			et := at.Elem()
-			specifyType(store, lookup, ct.Elt, et, nil)
+			specifyType(store, n, lookup, ct.Elt, et, nil)
 		default:
 			panic(fmt.Sprintf(
 				"expected array kind but got %s",
@@ -2469,7 +2469,7 @@ func specifyType(store Store, lookup map[Name]Type, tmpl Type, spec Type, specTy
 		case PrimitiveType:
 			if isGeneric(ct.Elt) {
 				if st.Kind() == StringKind {
-					specifyType(store, lookup, ct.Elt, Uint8Type, nil)
+					specifyType(store, n, lookup, ct.Elt, Uint8Type, nil)
 				} else {
 					panic(fmt.Sprintf(
 						"expected slice kind but got %s",
@@ -2485,11 +2485,11 @@ func specifyType(store Store, lookup map[Name]Type, tmpl Type, spec Type, specTy
 					spec.Kind()))
 			}
 		case *SliceType:
-			specifyType(store, lookup, ct.Elt, st.Elt, nil)
+			specifyType(store, n, lookup, ct.Elt, st.Elt, nil)
 		case *NativeType:
 			// NOTE: see note about type-checking.
 			et := st.Elem()
-			specifyType(store, lookup, ct.Elt, et, nil)
+			specifyType(store, n, lookup, ct.Elt, et, nil)
 		default:
 			panic(fmt.Sprintf(
 				"expected slice kind but got %s",
@@ -2498,14 +2498,14 @@ func specifyType(store Store, lookup map[Name]Type, tmpl Type, spec Type, specTy
 	case *MapType:
 		switch mt := baseOf(spec).(type) {
 		case *MapType:
-			specifyType(store, lookup, ct.Key, mt.Key, nil)
-			specifyType(store, lookup, ct.Value, mt.Value, nil)
+			specifyType(store, n, lookup, ct.Key, mt.Key, nil)
+			specifyType(store, n, lookup, ct.Value, mt.Value, nil)
 		case *NativeType:
 			// NOTE: see note about type-checking.
 			kt := mt.Key()
 			vt := mt.Elem()
-			specifyType(store, lookup, ct.Key, kt, nil)
-			specifyType(store, lookup, ct.Value, vt, nil)
+			specifyType(store, n, lookup, ct.Key, kt, nil)
+			specifyType(store, n, lookup, ct.Value, vt, nil)
 		default:
 			panic(fmt.Sprintf(
 				"expected map kind but got %s",
@@ -2544,7 +2544,7 @@ func specifyType(store Store, lookup map[Name]Type, tmpl Type, spec Type, specTy
 				generic := ct.Generic[:len(ct.Generic)-len(".Elem()")]
 				match, ok := lookup[generic]
 				if ok {
-					assertAssignableTo(spec, match.Elem(), false)
+					assertAssignableTo(n, spec, match.Elem(), false)
 					return // ok
 				} else {
 					// Panic here, because we don't know whether T
@@ -2558,7 +2558,7 @@ func specifyType(store Store, lookup map[Name]Type, tmpl Type, spec Type, specTy
 			} else {
 				match, ok := lookup[ct.Generic]
 				if ok {
-					assertAssignableTo(spec, match, false)
+					assertAssignableTo(n, spec, match, false)
 					return // ok
 				} else {
 					if isUntyped(spec) {
@@ -2576,9 +2576,9 @@ func specifyType(store Store, lookup map[Name]Type, tmpl Type, spec Type, specTy
 		switch cbt := baseOf(spec).(type) {
 		case *NativeType:
 			gnoType := store.Go2GnoType(cbt.Type)
-			specifyType(store, lookup, ct.Type, gnoType, nil)
+			specifyType(store, n, lookup, ct.Type, gnoType, nil)
 		default:
-			specifyType(store, lookup, ct.Type, cbt, nil)
+			specifyType(store, n, lookup, ct.Type, cbt, nil)
 		}
 	default:
 		// ignore, no generics.
diff --git a/gnovm/tests/files/add3.gno b/gnovm/tests/files/add3.gno
new file mode 100644
index 00000000000..c52e2c502dc
--- /dev/null
+++ b/gnovm/tests/files/add3.gno
@@ -0,0 +1,9 @@
+package main
+
+func main() {
+	a := 1
+	i := a + nil
+}
+
+// Error:
+// main/files/add3.gno:5:7: invalid operation: a<VPBlock(1,0)> + (const (undefined)) (mismatched types int and untyped nil)
diff --git a/gnovm/tests/files/assign38.gno b/gnovm/tests/files/assign38.gno
new file mode 100644
index 00000000000..5ef3549ccf6
--- /dev/null
+++ b/gnovm/tests/files/assign38.gno
@@ -0,0 +1,10 @@
+package main
+
+func main() {
+	a := 1
+	a = nil
+	println(a)
+}
+
+// Error:
+// main/files/assign38.gno:5:2: cannot use nil as int value in assignment
diff --git a/gnovm/tests/files/fun28.gno b/gnovm/tests/files/fun28.gno
new file mode 100644
index 00000000000..cf969f9f34b
--- /dev/null
+++ b/gnovm/tests/files/fun28.gno
@@ -0,0 +1,10 @@
+package main
+
+func f(i int) {}
+
+func main() {
+	f(nil)
+}
+
+// Error:
+// main/files/fun28.gno:6:2: cannot use nil as int value in argument to f<VPBlock(3,0)>
diff --git a/gnovm/tests/files/slice3.gno b/gnovm/tests/files/slice3.gno
new file mode 100644
index 00000000000..1132da01420
--- /dev/null
+++ b/gnovm/tests/files/slice3.gno
@@ -0,0 +1,9 @@
+package main
+
+func main() {
+	i := []string{nil}
+	println(i)
+}
+
+// Error:
+// main/files/slice3.gno:4:7: cannot use nil as string value in array, slice literal or map literal
diff --git a/gnovm/tests/files/var35.gno b/gnovm/tests/files/var35.gno
new file mode 100644
index 00000000000..87b1cc68590
--- /dev/null
+++ b/gnovm/tests/files/var35.gno
@@ -0,0 +1,8 @@
+package main
+
+func main() {
+	var i int = nil
+}
+
+// Error:
+// main/files/var35.gno:4:6: cannot use nil as int value in variable declaration