diff --git a/engine/tests/demo/leetcode5.gos b/engine/tests/demo/leetcode5.gos
index 8120065d..c811fdfb 100644
--- a/engine/tests/demo/leetcode5.gos
+++ b/engine/tests/demo/leetcode5.gos
@@ -83,9 +83,9 @@ func main() {
         //t(1000)
     }
     //assert(j == 10)
-	
+    
     result := longestPalindrome2(s)
-	assert(result == "aaabbbaaabbbaaa")
+    assert(result == "aaabbbaaabbbaaa")
     
 
     //assert(longestPalindrome("aa") == "aa")
diff --git a/engine/tests/group1/closure4.gos b/engine/tests/group1/closure4.gos
index 263c08cd..fd5ccad8 100644
--- a/engine/tests/group1/closure4.gos
+++ b/engine/tests/group1/closure4.gos
@@ -6,7 +6,7 @@ func tt() {
         c := 3
         return func()int {
             d := 2
-			return a + 1 + c + d
+            return a + 1 + c + d
         }
     }
     e := func() int {
@@ -26,7 +26,7 @@ func main() {
         c := 3
         return func()int {
             d := 2
-			return a + 1 + c + d
+            return a + 1 + c + d
         }
     }
     e := func() int {
diff --git a/engine/tests/group1/defer.gos b/engine/tests/group1/defer.gos
index 2a6d8f23..a9ed2acb 100644
--- a/engine/tests/group1/defer.gos
+++ b/engine/tests/group1/defer.gos
@@ -2,15 +2,15 @@ package main
 
 
 import (
-	"fmt"
+    "fmt"
 )
 
 func f() (result int) {
-	defer func() {
-		// result is accessed after it was set to 6 by the return statement
-		result *= 7
-	}()
-	return 6
+    defer func() {
+        // result is accessed after it was set to 6 by the return statement
+        result *= 7
+    }()
+    return 6
 }
 
 func main() {
@@ -18,7 +18,7 @@ func main() {
     fmt.Println(f())
     
     for i := 0; i <= 3; i++ {
-	    defer fmt.Println(i)
+        defer fmt.Println(i)
     }
     
 } 
diff --git a/engine/tests/group1/map1.gos b/engine/tests/group1/map1.gos
index 00653eed..684e8f97 100644
--- a/engine/tests/group1/map1.gos
+++ b/engine/tests/group1/map1.gos
@@ -2,43 +2,43 @@ package main
 
 
 func a () (int, int) {
-	return 6,7
+    return 6,7
 }
 
 func b() int {
-	return 8
+    return 8
 }
 
 func commaOk() {
-   
-   var i interface{} = "hello"
 
+    var i interface{} = "hello"
 
-   s, ok := i.(string)
-   assert(ok)
-   assert(s == "hello")
-   
-   s1 := i.(string)
-   assert(s1 == "hello")
 
+    s, ok := i.(string)
+    assert(ok)
+    assert(s == "hello")
+    
+    s1 := i.(string)
+    assert(s1 == "hello")
 
-	
-   	m := map[int]int{1:10, 2:20}
-   	int1, ok := m[1]
-	assert(int1 == 10)
-	assert(ok)
-	int2 := m[2]
-	assert(int2 == 20)
 
-	t1, t2 := a()
-	assert(t1 == 6)
-	assert(t2 == 7)
-	t3 := b()
-	assert(t3 == 8)
+
+    m := map[int]int{1:10, 2:20}
+    int1, ok := m[1]
+    assert(int1 == 10)
+    assert(ok)
+    int2 := m[2]
+    assert(int2 == 20)
+
+    t1, t2 := a()
+    assert(t1 == 6)
+    assert(t2 == 7)
+    t3 := b()
+    assert(t3 == 8)
 
     t01, t02 := 33, m[2]
     assert(t01 == 33)
-	assert(t02 == 20)
+    assert(t02 == 20)
 }
 
 func main() {
diff --git a/engine/tests/group1/pkg.gos b/engine/tests/group1/pkg.gos
index 91f525da..47862f76 100644
--- a/engine/tests/group1/pkg.gos
+++ b/engine/tests/group1/pkg.gos
@@ -29,10 +29,10 @@ func main() {
 }
 
 func fa () (int, int) {
-	assert(8 == fb())
-	return 6,7
+    assert(8 == fb())
+    return 6,7
 }
 
 func fb() int {
-	return 8
+    return 8
 }
diff --git a/engine/tests/group1/type.gos b/engine/tests/group1/type.gos
index 2b67b6d2..3f231734 100644
--- a/engine/tests/group1/type.gos
+++ b/engine/tests/group1/type.gos
@@ -38,7 +38,7 @@ type Add func(a int, b int) int
 
 func main() {
     type S2 struct {i int}
-	var s1 S1
+    var s1 S1
     //var s2 S2
 
     s1.Inc()
diff --git a/engine/tests/group1/typeswitch.gos b/engine/tests/group1/typeswitch.gos
index 5faaa4ab..564f0b51 100644
--- a/engine/tests/group1/typeswitch.gos
+++ b/engine/tests/group1/typeswitch.gos
@@ -1,47 +1,47 @@
 package main
 
 import (
-	"fmt"
+    "fmt"
 )
 
 
 type S1 struct {i int; j int}
 
 func typeName(v interface{}) string {
-	switch v.(type) {
-	case int:
-		return "int"
-	case string:
-		return "string" 
+    switch v.(type) {
+    case int:
+        return "int"
+    case string:
+        return "string"
     case *S1:
         return "S1"
-	default:
-		return "unknown"
-	}
+    default:
+        return "unknown"
+    }
 }
 
 
 func typeName2(v interface{}) string {
     kk := 2
-	switch i := v.(type) {
-	case int:
+    switch i := v.(type) {
+    case int:
         assert(i + kk == 890)
-		return "int"
-	case string:
-		return "string" 
+        return "int"
+    case string:
+        return "string"
     case *S1:
-		_ = i
+        _ = i
         return "S1"
-	case []int:
-		return "[]int"
-	case map[string]int:
-		return "map[string]int"
-	case map[string][]int:
-		return "map[string][]int"	
-	default:
-		return "unknown"
-	}
-	return "int"
+    case []int:
+        return "[]int"
+    case map[string]int:
+        return "map[string]int"
+    case map[string][]int:
+        return "map[string][]int"
+    default:
+        return "unknown"
+    }
+    return "int"
 }
 
 func main() {
diff --git a/engine/tests/group2/case0.gos b/engine/tests/group2/case0.gos
index c519c2b6..0de1a750 100644
--- a/engine/tests/group2/case0.gos
+++ b/engine/tests/group2/case0.gos
@@ -8,16 +8,16 @@ type TestKey struct {
 }
 
 func ptr() (*int, *int) {
-	i := 100
-	return &i, &i
+    i := 100
+    return &i, &i
 }
 
 
 func main() {
 
     var errNil error
-	var mapNil map[int]string
-	//mapNil[1] = "aa"
+    var mapNil map[int]string
+    //mapNil[1] = "aa"
 
     m := make(map[int]string)
     m[1] = "bb"
diff --git a/engine/tests/group2/case3.gos b/engine/tests/group2/case3.gos
index 969e4a97..6494df24 100644
--- a/engine/tests/group2/case3.gos
+++ b/engine/tests/group2/case3.gos
@@ -1,13 +1,13 @@
 package main
 
 import (
-	"fmt"
+    "fmt"
 )
 
 
 
 func main() {
-	var v = new(int)
+    var v = new(int)
     var vv = 2
     *v = 8
     var vvv = *v
@@ -17,7 +17,7 @@ func main() {
 
     var sa = &A{}
     
-	fmt.Println("Hello, playground", v, vv, vvv, s, s1, s3, sa)
+    fmt.Println("Hello, playground", v, vv, vvv, s, s1, s3, sa)
 }
 
 type A []int
diff --git a/engine/tests/group2/nil.gos b/engine/tests/group2/nil.gos
index bba66f03..50f1993c 100644
--- a/engine/tests/group2/nil.gos
+++ b/engine/tests/group2/nil.gos
@@ -1,7 +1,7 @@
 package main
 
 import (
-	"fmt"
+    "fmt"
 )
 
 type III interface{}
@@ -12,7 +12,7 @@ i int
 }
 
 func main() {
-	//var m []string
+    //var m []string
 
     var ia interface{}
     ia = 8
@@ -31,7 +31,7 @@ func main() {
     a = b
     b.i = 55
     
-	fmt.Println("Hello, playground", ia, ia == nil, ib, ib == nil, 10, a.i, b.i)
+    fmt.Println("Hello, playground", ia, ia == nil, ib, ib == nil, 10, a.i, b.i)
 
     c := &a
     d := &b
diff --git a/engine/tests/group2/unicode0.gos b/engine/tests/group2/unicode0.gos
index 104d3c16..a730a60c 100644
--- a/engine/tests/group2/unicode0.gos
+++ b/engine/tests/group2/unicode0.gos
@@ -1,38 +1,38 @@
 package main
 
 import (
-	"fmt"
+    "fmt"
     "unicode/utf8"
 )
 
 func ExampleDecodeLastRune() {
-	b := []byte("Hello, 世界")
-	utf8.DecodeLastRune(b)
+    b := []byte("Hello, 世界")
+    utf8.DecodeLastRune(b)
 
-	
-	for len(b) > 0 {
-		r, size := utf8.DecodeLastRune(b)
-		fmt.Println("%c %v\n", r, size)
+    
+    for len(b) > 0 {
+        r, size := utf8.DecodeLastRune(b)
+        fmt.Println("%c %v\n", r, size)
 
-		b = b[:len(b)-size]
-	}
-	
-	// Output:
-	// 界 3
-	// 世 3
-	//   1
-	// , 1
-	// o 1
-	// l 1
-	// l 1
-	// e 1
-	// H 1
+        b = b[:len(b)-size]
+    }
+    
+    // Output:
+    // 界 3
+    // 世 3
+    //   1
+    // , 1
+    // o 1
+    // l 1
+    // l 1
+    // e 1
+    // H 1
 }
 
 
 func main() {
     ExampleDecodeLastRune()
-	fmt.Println(utf8.RuneError, "a \n b👌")
-	s := "\\ \n \\"
-	fmt.Println(s[0], len(s), s)
+    fmt.Println(utf8.RuneError, "a \n b👌")
+    s := "\\ \n \\"
+    fmt.Println(s[0], len(s), s)
 }
\ No newline at end of file
diff --git a/parser/src/ast.rs b/parser/src/ast.rs
index 04dca8f8..b8359688 100644
--- a/parser/src/ast.rs
+++ b/parser/src/ast.rs
@@ -860,10 +860,10 @@ pub struct BadDecl {
 //
 // Relationship between Tok value and Specs element type:
 //
-//	Token::IMPORT  ImportSpec
-//	Token::CONST   ValueSpec
-//	Token::TYPE    TypeSpec
-//	Token::VAR     ValueSpec
+// Token::IMPORT  ImportSpec
+// Token::CONST   ValueSpec
+// Token::TYPE    TypeSpec
+// Token::VAR     ValueSpec
 #[derive(Debug)]
 pub struct GenDecl {
     pub token_pos: position::Pos,
diff --git a/parser/src/parser.rs b/parser/src/parser.rs
index ba17215c..741de647 100644
--- a/parser/src/parser.rs
+++ b/parser/src/parser.rs
@@ -174,7 +174,7 @@ impl<'a> Parser<'a> {
             unreachable!();
         };
         let list = &ass_stmt!(self, assign).lhs;
-	    let mut n = 0; // number of new variables
+        let mut n = 0; // number of new variables
         for expr in list {
             match expr { 
                 Expr::Ident(id) => {
@@ -597,7 +597,7 @@ impl<'a> Parser<'a> {
         self.trace_begin("FieldDecl");
 
         // 1st FieldDecl
-	    // A type name used as an anonymous field looks like a field identifier.
+        // A type name used as an anonymous field looks like a field identifier.
         let mut list = vec![];
         loop {
             list.push(self.parse_var_type(false));
@@ -726,7 +726,7 @@ impl<'a> Parser<'a> {
         self.trace_begin("ParameterList");
 
         // 1st ParameterDecl
-	    // A list of identifiers looks like a list of type names.
+        // A list of identifiers looks like a list of type names.
         let mut list = vec![];
         loop {
             list.push(self.parse_var_type(ellipsis_ok));
@@ -747,8 +747,8 @@ impl<'a> Parser<'a> {
             let field = new_field!(self, idents, t, None);
             params.push(field);
             // Go spec: The scope of an identifier denoting a function
-			// parameter or result variable is the function body.
-			self.declare(DeclObj::Field(field), EntityData::NoData,
+            // parameter or result variable is the function body.
+            self.declare(DeclObj::Field(field), EntityData::NoData,
                 EntityKind::Var, &scope);
             if let Some(ident) = to_resolve {
                 self.resolve(&ident);
@@ -1967,7 +1967,7 @@ impl<'a> Parser<'a> {
                     // to the variable declared in the initial SimpleStmt.
                     // Introduce extra scope to avoid redeclaration errors:
                     //
-                    //	switch t := 0; t := x.(T) { ... }
+                    //    switch t := 0; t := x.(T) { ... }
                     //
                     // (this code is not valid Go because the first t
                     // cannot be accessed and thus is never used, the extra
@@ -2021,7 +2021,7 @@ impl<'a> Parser<'a> {
                 // SendStmt
                 if lhs.len() > 1 {
                     self.error_expected(lhs[0].pos(&self.objects), "1 expression");
-				    // continue with first expression
+                    // continue with first expression
                 }
                 let arrow = self.pos;
                 self.next();
@@ -2150,7 +2150,7 @@ impl<'a> Parser<'a> {
                     }
                 };
                 // parseSimpleStmt returned a right-hand side that
-		        // is a single unary expression of the form "range x"
+                // is a single unary expression of the form "range x"
                 if let Expr::Unary(unary) = ass.rhs.remove(0) {
                     Stmt::Range(Rc::new(RangeStmt{
                         for_pos: pos,
@@ -2190,9 +2190,9 @@ impl<'a> Parser<'a> {
                 Stmt::Decl(Rc::new(self.parse_decl(Token::is_stmt_start))),
             Token::IDENT(_) | Token::INT(_) | Token::FLOAT(_) | Token::IMAG(_) |
             Token::CHAR(_) | Token::STRING(_) | Token::FUNC | Token::LPAREN | // operands
-		    Token::LBRACK | Token::STRUCT | 
+            Token::LBRACK | Token::STRUCT | 
             Token::MAP | Token::CHAN | Token::INTERFACE | // composite types
-		    Token::ADD | Token::SUB | Token::MUL | Token::AND |
+            Token::ADD | Token::SUB | Token::MUL | Token::AND |
             Token::XOR | Token::ARROW | Token::NOT => { // unary operators
                 let s = self.parse_simple_stmt(ParseSimpleMode::LabelOk).0;
                 if let Stmt::Labeled(_) = s {} else {self.expect_semi();}
@@ -2326,9 +2326,9 @@ impl<'a> Parser<'a> {
         }
 
         // Go spec: The scope of a constant or variable identifier declared inside
-	    // a function begins at the end of the ConstSpec or VarSpec and ends at
-	    // the end of the innermost containing block.
-	    // (Global identifiers are resolved in a separate phase after parsing.)
+        // a function begins at the end of the ConstSpec or VarSpec and ends at
+        // the end of the innermost containing block.
+        // (Global identifiers are resolved in a separate phase after parsing.)
         let spec =  specs_mut!(self_).insert(Spec::Value(Rc::new(ValueSpec{
             names: idents, typ: typ, values: values})));
         let kind = if let Token::VAR = keyword {
@@ -2349,9 +2349,9 @@ impl<'a> Parser<'a> {
 
         let ident = self.parse_ident();
         // Go spec: The scope of a type identifier declared inside a function begins
-	    // at the identifier in the TypeSpec and ends at the end of the innermost
-	    // containing block.
-	    // (Global identifiers are resolved in a separate phase after parsing.)
+        // at the identifier in the TypeSpec and ends at the end of the innermost
+        // containing block.
+        // (Global identifiers are resolved in a separate phase after parsing.)
         let placeholder = Expr::new_bad(0, 0);
         let spec_val = Spec::Type(Rc::new(TypeSpec{
             name: ident, assign: 0, typ: placeholder
@@ -2497,7 +2497,7 @@ impl<'a> Parser<'a> {
         let err_count = self.errors.len();
         let pos = self.expect(&Token::PACKAGE);
         // Go spec: The package clause is not a declaration;
-	    // the package name does not appear in any scope.
+        // the package name does not appear in any scope.
         let ident = self.parse_ident();
         if ident!(self, ident).name == "_" {
             self.error_str(self.pos, "invalid package name _");
@@ -2505,8 +2505,8 @@ impl<'a> Parser<'a> {
         self.expect_semi();
 
         // Don't bother parsing the rest if we had errors parsing the package clause.
-	    // Likely not a Go source file at all.
-	    if self.errors.len() > err_count {
+        // Likely not a Go source file at all.
+        if self.errors.len() > err_count {
             self.trace_end();
             return None
         }
@@ -2555,10 +2555,10 @@ impl<'a> Parser<'a> {
 
 #[cfg(test)]
 mod test {
-	use super::*;
+    use super::*;
 
-	#[test]
-	fn test_parser () {
+    #[test]
+    fn test_parser () {
         let mut fs = position::FileSet::new();
         let f = fs.add_file("testfile1.gs".to_string(), None, 1000);
 
diff --git a/types/src/check/decl.rs b/types/src/check/decl.rs
index 30ed753e..17f4d4f6 100644
--- a/types/src/check/decl.rs
+++ b/types/src/check/decl.rs
@@ -416,11 +416,11 @@ impl<'a> Checker<'a> {
             // The underlying type of named may be itself a named type that is
             // incomplete:
             //
-            //	type (
-            //		A B
-            //		B *C
-            //		C A
-            //	)
+            // type (
+            //     A B
+            //     B *C
+            //     C A
+            // )
             //
             // The type of C is the (named) type of A which is incomplete,
             // and which has as its underlying type the named type B.
diff --git a/types/src/lookup.rs b/types/src/lookup.rs
index 8e1edd9f..119548b0 100644
--- a/types/src/lookup.rs
+++ b/types/src/lookup.rs
@@ -200,9 +200,9 @@ impl MethodSet {
 /// The last index entry is the field or method index in the (possibly embedded)
 /// type where the entry was found, either:
 ///
-///	1) the list of declared methods of a named type; or
-///	2) the list of all methods (method set) of an interface type; or
-///	3) the list of fields of a struct type.
+/// 1) the list of declared methods of a named type; or
+/// 2) the list of all methods (method set) of an interface type; or
+/// 3) the list of fields of a struct type.
 ///
 /// The earlier index entries are the indices of the embedded struct fields
 /// traversed to get to the found entry, starting at depth 0.
diff --git a/types/src/selection.rs b/types/src/selection.rs
index 00454211..65bd7386 100644
--- a/types/src/selection.rs
+++ b/types/src/selection.rs
@@ -16,18 +16,18 @@ pub enum SelectionKind {
 /// A Selection describes a selector expression x.f.
 /// For the declarations:
 ///
-///	type T struct{ x int; E }
-///	type E struct{}
-///	func (e E) m() {}
-///	var p *T
+/// type T struct{ x int; E }
+/// type E struct{}
+/// func (e E) m() {}
+/// var p *T
 ///
 /// the following relations exist:
 ///
-///	Selector    Kind          Recv    Obj    Type               Index     Indirect
+/// Selector    Kind          Recv    Obj    Type               Index     Indirect
 ///
-///	p.x         FieldVal      T       x      int                {0}       true
-///	p.m         MethodVal     *T      m      func (e *T) m()    {1, 0}    true
-///	T.m         MethodExpr    T       m      func m(_ T)        {1, 0}    false
+/// p.x         FieldVal      T       x      int                {0}       true
+/// p.m         MethodVal     *T      m      func (e *T) m()    {1, 0}    true
+/// T.m         MethodExpr    T       m      func m(_ T)        {1, 0}    false
 ///
 #[derive(Clone, Debug)]
 pub struct Selection {
@@ -89,9 +89,9 @@ impl Selection {
     /// The last indices entry is the field or method indices of the type declaring f;
     /// either:
     ///
-    ///	1) the list of declared methods of a named type; or
-    ///	2) the list of methods of an interface type; or
-    ///	3) the list of fields of a struct type.
+    /// 1) the list of declared methods of a named type; or
+    /// 2) the list of methods of an interface type; or
+    /// 3) the list of fields of a struct type.
     ///
     /// The earlier indices entries are the indices of the embedded fields implicitly
     /// traversed to get from (the type of) x to f, starting at embedding depth 0.
diff --git a/types/tests/data/builtins.gos b/types/tests/data/builtins.gos
index 55b1d99d..0b34c542 100644
--- a/types/tests/data/builtins.gos
+++ b/types/tests/data/builtins.gos
@@ -449,7 +449,7 @@ func make1() {
 	_ = make([]int, 10 /* ERROR length and capacity swapped */ , 9)
 	_ = make([]int, 1 /* ERROR overflows */ <<100, 12345)
 	_ = make([]int, m /* ERROR must be integer */ )
-        _ = &make /* ERROR cannot take address */ ([]int, 0)
+	_ = &make /* ERROR cannot take address */ ([]int, 0)
 
 	// maps
 	_ = make /* ERROR arguments */ (map[int]string, 10, 20)
@@ -460,7 +460,7 @@ func make1() {
 	_ = make(map[int]float32, int64(n))
 	_ = make(map[string]bool, 10.0)
 	_ = make(map[string]bool, 10.0<<s)
-        _ = &make /* ERROR cannot take address */ (map[string]bool)
+	_ = &make /* ERROR cannot take address */ (map[string]bool)
 
 	// channels
 	_ = make /* ERROR arguments */ (chan int, 10, 20)
@@ -472,7 +472,7 @@ func make1() {
 	_ = make(chan string, int64(n))
 	_ = make(chan bool, 10.0)
 	_ = make(chan bool, 10.0<<s)
-        _ = &make /* ERROR cannot take address */ (chan bool)
+	_ = &make /* ERROR cannot take address */ (chan bool)
 
 	make /* ERROR not used */ ([]int, 10)
 
@@ -498,7 +498,7 @@ func new1() {
 	q := new(*float64)
 	_ = *p == **q
 	new /* ERROR not used */ (int)
-        _ = &new /* ERROR cannot take address */ (int)
+	_ = &new /* ERROR cannot take address */ (int)
 
 	_ = new(int... /* ERROR invalid use of \.\.\. */ )
 }
@@ -653,39 +653,39 @@ func recover2() {
 }
 
 // assuming types.DefaultPtrSize == 8
-type S0 struct{      // offset
+type S0 struct{  // offset
 	a bool       //  0
 	b rune       //  4
 	c *int       //  8
 	d bool       // 16
 	e complex128 // 24
-}                    // 40
+}                // 40
 
 type S1 struct{   // offset
 	x float32 //  0
 	y string  //  8
 	z *S1     // 24
 	S0        // 32
-}                 // 72
+}             // 72
 
 type S2 struct{ // offset
 	*S1     //  0
-}               //  8
+}           //  8
 
 type S3 struct { // offset
 	a int64  //  0
 	b int32  //  8
-}                // 12
+}            // 12
 
 type S4 struct { // offset
 	S3       //  0
 	int32    // 12
-}                // 16
+}            // 16
 
 type S5 struct {   // offset
 	a [3]int32 //  0
 	b int32    // 12
-}                  // 16
+}              // 16
 
 func (S2) m() {}
 
diff --git a/types/tests/data/issues.src b/types/tests/data/issues.src
index 3eb4d8db..88a7a921 100644
--- a/types/tests/data/issues.src
+++ b/types/tests/data/issues.src
@@ -10,23 +10,23 @@ package issues
 
 
 func issue8066() {
-	const (
-		//_ = float32(340282356779733661637539395458142568447)
-		_ = float32(340282356779733661637539395458142568448 /* ERROR cannot convert */ )
-	)
+    const (
+        //_ = float32(340282356779733661637539395458142568447)
+        _ = float32(340282356779733661637539395458142568448 /* ERROR cannot convert */ )
+    )
 }
 
 // Check that a missing identifier doesn't lead to a spurious error cascade.
 func issue8799a() {
-	x, ok := missing /* ERROR undeclared */ ()
-	_ = !ok
-	_ = x
+    x, ok := missing /* ERROR undeclared */ ()
+    _ = !ok
+    _ = x
 }
 
 func issue8799b(x int, ok bool) {
-	x, ok = missing /* ERROR undeclared */ ()
-	_ = !ok
-	_ = x
+    x, ok = missing /* ERROR undeclared */ ()
+    _ = !ok
+    _ = x
 }
 
 
@@ -38,49 +38,49 @@ func f2() (a, b []int)      { return }
 func append_([]int, ...int) {}
 
 func issue9473(a []int, b ...int) {
-	// variadic builtin function
-	_ = append(f0())
-	_ = append(f0(), f0()...)
-	_ = append(f1())
-	_ = append(f2 /* ERROR cannot use .* in argument */ ())
-	_ = append(f2()... /* ERROR cannot use ... */ )
-	_ = append(f0(), f1 /* ERROR 2-valued f1 */ ())
-	_ = append(f0(), f2 /* ERROR 2-valued f2 */ ())
-	_ = append(f0(), f1 /* ERROR 2-valued f1 */ ()...)
-	_ = append(f0(), f2 /* ERROR 2-valued f2 */ ()...)
-
-	// variadic user-defined function
-	append_(f0())
-	append_(f0(), f0()...)
-	append_(f1())
-	append_(f2 /* ERROR cannot use .* in argument */ ())
-	append_(f2()... /* ERROR cannot use ... */ )
-	append_(f0(), f1 /* ERROR 2-valued f1 */ ())
-	append_(f0(), f2 /* ERROR 2-valued f2 */ ())
-	append_(f0(), f1 /* ERROR 2-valued f1 */ ()...)
-	append_(f0(), f2 /* ERROR 2-valued f2 */ ()...)
+    // variadic builtin function
+    _ = append(f0())
+    _ = append(f0(), f0()...)
+    _ = append(f1())
+    _ = append(f2 /* ERROR cannot use .* in argument */ ())
+    _ = append(f2()... /* ERROR cannot use ... */ )
+    _ = append(f0(), f1 /* ERROR 2-valued f1 */ ())
+    _ = append(f0(), f2 /* ERROR 2-valued f2 */ ())
+    _ = append(f0(), f1 /* ERROR 2-valued f1 */ ()...)
+    _ = append(f0(), f2 /* ERROR 2-valued f2 */ ()...)
+
+    // variadic user-defined function
+    append_(f0())
+    append_(f0(), f0()...)
+    append_(f1())
+    append_(f2 /* ERROR cannot use .* in argument */ ())
+    append_(f2()... /* ERROR cannot use ... */ )
+    append_(f0(), f1 /* ERROR 2-valued f1 */ ())
+    append_(f0(), f2 /* ERROR 2-valued f2 */ ())
+    append_(f0(), f1 /* ERROR 2-valued f1 */ ()...)
+    append_(f0(), f2 /* ERROR 2-valued f2 */ ()...)
 }
 
 // Check that embedding a non-interface type in an interface results in a good error message.
 func issue10979() {
-	type _ interface {
-		int /* ERROR int is not an interface */
-	}
-	type T struct{}
-	type _ interface {
-		T /* ERROR T is not an interface */
-	}
-	type _ interface {
-		nosuchtype /* ERROR undeclared name: nosuchtype */
-	}
-
-	type _ interface {
-		nosuchpkg /* ERROR undeclared name: nosuchpkg */ .Nosuchtype
-	}
-	type I interface {
-		I /* ERROR I\.m \(value of type func\(.*\)\) is not a type */ .m
-		m()
-	}
+    type _ interface {
+        int /* ERROR int is not an interface */
+    }
+    type T struct{}
+    type _ interface {
+        T /* ERROR T is not an interface */
+    }
+    type _ interface {
+        nosuchtype /* ERROR undeclared name: nosuchtype */
+    }
+
+    type _ interface {
+        nosuchpkg /* ERROR undeclared name: nosuchpkg */ .Nosuchtype
+    }
+    type I interface {
+        I /* ERROR I\.m \(value of type func\(.*\)\) is not a type */ .m
+        m()
+    }
 }
 
 // issue11347
@@ -92,128 +92,128 @@ var a3, b3 /* ERROR cycle */ = int /* ERROR cannot initialize */ /* ERROR cannot
 // issue10260
 // Check that error messages explain reason for interface assignment failures.
 type (
-	I0 interface{}
-	I1 interface{ foo() }
-	I2 interface{ foo(x int) }
-	T0 struct{}
-	T1 struct{}
-	T2 struct{}
+    I0 interface{}
+    I1 interface{ foo() }
+    I2 interface{ foo(x int) }
+    T0 struct{}
+    T1 struct{}
+    T2 struct{}
 )
 
 func (*T1) foo() {}
 func (*T2) foo(x int) {}
 
 func issue10260() {
-	var (
-		i0 I0
-		i1 I1
-		i2 I2
-		t0 *T0
-		t1 *T1
-		t2 *T2
-	)
-	i1 = i0 /* ERROR cannot use .* missing method foo */
-	i1 = t0 /* ERROR cannot use .* missing method foo */
-	i1 = i2 /* ERROR cannot use .* wrong type for method foo */
-	i1 = t2 /* ERROR cannot use .* wrong type for method foo */
-	i2 = i1 /* ERROR cannot use .* wrong type for method foo */
-	i2 = t1 /* ERROR cannot use .* wrong type for method foo */
-
-	_ = func() I1 { return i0 /* ERROR cannot use .* missing method foo */ }
-	_ = func() I1 { return t0 /* ERROR cannot use .* missing method foo */ }
-	_ = func() I1 { return i2 /* ERROR cannot use .* wrong type for method foo */ }
-	_ = func() I1 { return t2 /* ERROR cannot use .* wrong type for method foo */ }
-	_ = func() I2 { return i1 /* ERROR cannot use .* wrong type for method foo */ }
-	_ = func() I2 { return t1 /* ERROR cannot use .* wrong type for method foo */ }
-
-	// a few more - less exhaustive now
-
-	f := func(I1, I2){}
-	f(i0 /* ERROR cannot use .* missing method foo */ , i1 /* ERROR cannot use .* wrong type for method foo */)
-
-	_ = [...]I1{i0 /* ERROR cannot use .* missing method foo */ }
-	_ = [...]I1{i2 /* ERROR cannot use .* wrong type for method foo */ }
-	_ = []I1{i0 /* ERROR cannot use .* missing method foo */ }
-	_ = []I1{i2 /* ERROR cannot use .* wrong type for method foo */ }
-	_ = map[int]I1{0: i0 /* ERROR cannot use .* missing method foo */ }
-	_ = map[int]I1{0: i2 /* ERROR cannot use .* wrong type for method foo */ }
-
-	make(chan I1) <- i0 /* ERROR cannot use .* in send: missing method foo */
-	make(chan I1) <- i2 /* ERROR cannot use .* in send: wrong type for method foo */
+    var (
+        i0 I0
+        i1 I1
+        i2 I2
+        t0 *T0
+        t1 *T1
+        t2 *T2
+    )
+    i1 = i0 /* ERROR cannot use .* missing method foo */
+    i1 = t0 /* ERROR cannot use .* missing method foo */
+    i1 = i2 /* ERROR cannot use .* wrong type for method foo */
+    i1 = t2 /* ERROR cannot use .* wrong type for method foo */
+    i2 = i1 /* ERROR cannot use .* wrong type for method foo */
+    i2 = t1 /* ERROR cannot use .* wrong type for method foo */
+
+    _ = func() I1 { return i0 /* ERROR cannot use .* missing method foo */ }
+    _ = func() I1 { return t0 /* ERROR cannot use .* missing method foo */ }
+    _ = func() I1 { return i2 /* ERROR cannot use .* wrong type for method foo */ }
+    _ = func() I1 { return t2 /* ERROR cannot use .* wrong type for method foo */ }
+    _ = func() I2 { return i1 /* ERROR cannot use .* wrong type for method foo */ }
+    _ = func() I2 { return t1 /* ERROR cannot use .* wrong type for method foo */ }
+
+    // a few more - less exhaustive now
+
+    f := func(I1, I2){}
+    f(i0 /* ERROR cannot use .* missing method foo */ , i1 /* ERROR cannot use .* wrong type for method foo */)
+
+    _ = [...]I1{i0 /* ERROR cannot use .* missing method foo */ }
+    _ = [...]I1{i2 /* ERROR cannot use .* wrong type for method foo */ }
+    _ = []I1{i0 /* ERROR cannot use .* missing method foo */ }
+    _ = []I1{i2 /* ERROR cannot use .* wrong type for method foo */ }
+    _ = map[int]I1{0: i0 /* ERROR cannot use .* missing method foo */ }
+    _ = map[int]I1{0: i2 /* ERROR cannot use .* wrong type for method foo */ }
+
+    make(chan I1) <- i0 /* ERROR cannot use .* in send: missing method foo */
+    make(chan I1) <- i2 /* ERROR cannot use .* in send: wrong type for method foo */
 }
 
 // Check that constants representable as integers are in integer form
 // before being used in operations that are only defined on integers.
 func issue14229() {
-	// from the issue
-	const _ = int64(-1<<63) % 1e6
-
-	// related
-	const (
-		a int = 3
-		b = 4.0
-		_ = a / b
-		_ = a % b
-		_ = b / a
-		_ = b % a
-	)
+    // from the issue
+    const _ = int64(-1<<63) % 1e6
+
+    // related
+    const (
+        a int = 3
+        b = 4.0
+        _ = a / b
+        _ = a % b
+        _ = b / a
+        _ = b % a
+    )
 }
 
 // Check that in a n:1 variable declaration with type and initialization
 // expression the type is distributed to all variables of the lhs before
 // the initialization expression assignment is checked.
 func issue15755() {
-	// from issue
-	var i interface{}
-	type b bool
-	var x, y b = i.(b)
-	_ = x == y
-
-	// related: we should see an error since the result of f1 is ([]int, int)
-	var u, v []int = f1 /* ERROR cannot use f1 */ ()
-	_ = u
-	_ = v
+    // from issue
+    var i interface{}
+    type b bool
+    var x, y b = i.(b)
+    _ = x == y
+
+    // related: we should see an error since the result of f1 is ([]int, int)
+    var u, v []int = f1 /* ERROR cannot use f1 */ ()
+    _ = u
+    _ = v
 }
 
 // Test that we don't get "declared but not used"
 // errors in the context of invalid/C objects.
 func issue20358() {
-	var F C /* ERROR "undeclared" */ .F
-	var A C /* ERROR "undeclared" */ .A
-	var S C /* ERROR "undeclared" */ .S
-	type T C /* ERROR "undeclared" */ .T
-	type P C /* ERROR "undeclared" */ .P
-
-	// these variables must be "used" even though
-	// the LHS expressions/types below in which
-	// context they are used are unknown/invalid
-	var f, a, s1, s2, s3, t int
-
-	_ = F(f)
-	_ = A[a]
-	_ = S[s1:s2:s3]
-	_ = T{t}
-	_ = P{f: p}
+    var F C /* ERROR "undeclared" */ .F
+    var A C /* ERROR "undeclared" */ .A
+    var S C /* ERROR "undeclared" */ .S
+    type T C /* ERROR "undeclared" */ .T
+    type P C /* ERROR "undeclared" */ .P
+
+    // these variables must be "used" even though
+    // the LHS expressions/types below in which
+    // context they are used are unknown/invalid
+    var f, a, s1, s2, s3, t int
+
+    _ = F(f)
+    _ = A[a]
+    _ = S[s1:s2:s3]
+    _ = T{t}
+    _ = P{f: p}
 }
 
 // Test that we don't declare lhs variables in short variable
 // declarations before we type-check function literals on the
 // rhs.
 func issue24026() {
-	f := func() int { f(0) /* must refer to outer f */; return 0 }
-	_ = f
-
-	_ = func() {
-		f := func() { _ = f() /* must refer to outer f */ }
-		_ = f
-	}
-
-	// b and c must not be visible inside function literal
-	a := 0
-	a, b, c := func() (int, int, int) {
-		return a, b /* ERROR undeclared */ , c /* ERROR undeclared */
-	}()
-	_, _ = b, c
+    f := func() int { f(0) /* must refer to outer f */; return 0 }
+    _ = f
+
+    _ = func() {
+        f := func() { _ = f() /* must refer to outer f */ }
+        _ = f
+    }
+
+    // b and c must not be visible inside function literal
+    a := 0
+    a, b, c := func() (int, int, int) {
+        return a, b /* ERROR undeclared */ , c /* ERROR undeclared */
+    }()
+    _, _ = b, c
 }
 
 func f(int) {} // for issue24026
@@ -231,30 +231,30 @@ func issue24140(x interface{}) int {
 
 // Test that we don't crash when the 'if' condition is missing.
 func issue25438() {
-	if { /*ERROR missing condition */ }
-	if x := 0; /*ERROR missing condition */ { _ = x }
-	if
-	{ /*ERROR missing condition */ }
+    if { /*ERROR missing condition */ }
+    if x := 0; /*ERROR missing condition */ { _ = x }
+    if
+    { /*ERROR missing condition */ }
 }
 
 // Test that we can embed alias type names in interfaces.
 type issue25301 interface {
-	E
+    E
 }
 
 type E = interface {
-	m()
+    m()
 }
 
 // Test case from issue. Eventually we may disallow this due
 // to the cycle via the alias type name. But for now we make
 // sure this is accepted.
 type issue25301b = interface {
-	m() interface{ issue25301b }
+    m() interface{ issue25301b }
 }
 
 type issue25301c interface {
-	notE // ERROR struct\{\} is not an interface
+    notE // ERROR struct\{\} is not an interface
 }
 
 type notE = struct{}
@@ -270,23 +270,23 @@ const preloadLimit LNumber = 128
 type LNumber float64
 func (LNumber) assertFunction() *LFunction
 type LFunction struct {
-	GFunction LGFunction
+    GFunction LGFunction
 }
 type LGFunction func(*LState)
 type LState struct {
-	reg *registry
+    reg *registry
 }
 type registry struct {
-	alloc *allocator
+    alloc *allocator
 }
 type allocator struct {
-	_ [int(preloadLimit)]int
+    _ [int(preloadLimit)]int
 }
 
 // Test that we don't crash when type-checking composite literals
 // containing errors in the type.
 var issue27346 = [][n /* ERROR undeclared */ ]int{
-	0: {},
+    0: {},
 }
 
 var issue22467 = map[int][... /* ERROR invalid use of ... */ ]int{0: {}}
@@ -305,18 +305,18 @@ func issue28281g() (... /*ERROR expected type */ TT)
 
 
 type T struct {
-	x int
-	E1
-	E2
+    x int
+    E1
+    E2
 }
 
 type E1 struct{ f int }
 type E2 struct{ f int }
 
 func issue26234b(x T) {
-	_ = x.f /* ERROR ambiguous selector f */
+    _ = x.f /* ERROR ambiguous selector f */
 }
 
 func issue26234c() {
-	T.x /* ERROR  has no method x */ ()
+    T.x /* ERROR  has no method x */ ()
 }
diff --git a/types/tests/data/stmt0.src b/types/tests/data/stmt0.src
index ffd5e9a1..7d693ea1 100644
--- a/types/tests/data/stmt0.src
+++ b/types/tests/data/stmt0.src
@@ -422,7 +422,7 @@ func switches0() {
 	true := "false"
 	_ = true
 	// A tagless switch is equivalent to the bool
-        // constant true, not the identifier 'true'.
+	// constant true, not the identifier 'true'.
 	switch {
 	case "false" /* ERROR "cannot convert" */:
 	}