--- /dev/null
+// $G $D/$F.go && $L $F.$A && ./$A.out
+
+// 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.
+
+// Test that basic operations on named types are valid
+// and preserve the type.
+
+package main
+
+type Array [10]byte
+type Bool bool
+type Chan chan int
+type Float float
+type Int int
+type Map map[int]byte
+type Slice []byte
+type String string
+
+// Calling these functions checks at compile time that the argument
+// can be converted implicitly to (used as) the given type.
+func asArray(Array) {}
+func asBool(Bool) {}
+func asChan(Chan) {}
+func asFloat(Float) {}
+func asInt(Int) {}
+func asMap(Map) {}
+func asSlice(Slice) {}
+func asString(String) {}
+
+func (Map) M() {}
+
+
+// These functions check at run time that the default type
+// (in the absence of any implicit conversion hints)
+// is the given type.
+func isArray(x interface{}) { _ = x.(Array) }
+func isBool(x interface{}) { _ = x.(Bool) }
+func isChan(x interface{}) { _ = x.(Chan) }
+func isFloat(x interface{}) { _ = x.(Float) }
+func isInt(x interface{}) { _ = x.(Int) }
+func isMap(x interface{}) { _ = x.(Map) }
+func isSlice(x interface{}) { _ = x.(Slice) }
+func isString(x interface{}) { _ = x.(String) }
+
+func main() {
+ var (
+ a Array;
+ b Bool = true;
+ c Chan = make(Chan);
+ f Float = 1;
+ i Int = 1;
+ m Map = make(Map);
+ slice Slice = make(Slice, 10);
+ str String = "hello";
+ )
+
+ asArray(a);
+ isArray(a);
+ asArray(*&a);
+ isArray(*&a);
+ asArray(Array{});
+ isArray(Array{});
+
+ asBool(b);
+ isBool(b);
+ asBool(!b);
+ isBool(!b);
+ asBool(true);
+ asBool(1!=2);
+ asBool(*&b);
+ isBool(*&b);
+ asBool(Bool(true));
+ isBool(Bool(true));
+ asBool(i < Int(f));
+
+ _, b = m[2];
+ m[2] = 1, b;
+
+ b = c<-1;
+ _ = b;
+ asBool(c<-1);
+
+ _, b = <-c;
+ _ = b;
+
+ var inter interface{};
+ _, b = inter.(Map);
+ _ = b;
+
+ var minter interface{M()};
+ _, b = minter.(Map);
+ _ = b;
+
+ asBool(closed(c));
+ b = closed(c);
+ _ = b;
+
+ asChan(c);
+ isChan(c);
+ asChan(make(Chan));
+ isChan(make(Chan));
+ asChan(*&c);
+ isChan(*&c);
+ asChan(Chan(nil));
+ isChan(Chan(nil));
+
+ asFloat(f);
+ isFloat(f);
+ asFloat(-f);
+ isFloat(-f);
+ asFloat(+f);
+ isFloat(+f);
+ asFloat(f+1);
+ isFloat(f+1);
+ asFloat(1+f);
+ isFloat(1+f);
+ asFloat(f+f);
+ isFloat(f+f);
+ f++;
+ f+=2;
+ asFloat(f-1);
+ isFloat(f-1);
+ asFloat(1-f);
+ isFloat(1-f);
+ asFloat(f-f);
+ isFloat(f-f);
+ f--;
+ f-=2;
+ asFloat(f*2.5);
+ isFloat(f*2.5);
+ asFloat(2.5*f);
+ isFloat(2.5*f);
+ asFloat(f*f);
+ isFloat(f*f);
+ f*=4;
+ asFloat(f/2.5);
+ isFloat(f/2.5);
+ asFloat(2.5/f);
+ isFloat(2.5/f);
+ asFloat(f/f);
+ isFloat(f/f);
+ f/=4;
+ asFloat(f);
+ isFloat(f);
+ f = 5;
+ asFloat(*&f);
+ isFloat(*&f);
+ asFloat(234);
+ asFloat(Float(234));
+ isFloat(Float(234));
+ asFloat(1.2);
+ asFloat(Float(i));
+ isFloat(Float(i));
+
+ asInt(i);
+ isInt(i);
+ asInt(-i);
+ isInt(-i);
+ asInt(^i);
+ isInt(^i);
+ asInt(+i);
+ isInt(+i);
+ asInt(i+1);
+ isInt(i+1);
+ asInt(1+i);
+ isInt(1+i);
+ asInt(i+i);
+ isInt(i+i);
+ i++;
+ i+=1;
+ asInt(i-1);
+ isInt(i-1);
+ asInt(1-i);
+ isInt(1-i);
+ asInt(i-i);
+ isInt(i-i);
+ i--;
+ i-=1;
+ asInt(i*2);
+ isInt(i*2);
+ asInt(2*i);
+ isInt(2*i);
+ asInt(i*i);
+ isInt(i*i);
+ i*=2;
+ asInt(i/5);
+ isInt(i/5);
+ asInt(5/i);
+ isInt(5/i);
+ asInt(i/i);
+ isInt(i/i);
+ i/=2;
+ asInt(i%5);
+ isInt(i%5);
+ asInt(5%i);
+ isInt(5%i);
+ asInt(i%i);
+ isInt(i%i);
+ i%=2;
+ asInt(i&5);
+ isInt(i&5);
+ asInt(5&i);
+ isInt(5&i);
+ asInt(i&i);
+ isInt(i&i);
+ i&=2;
+ asInt(i&^5);
+ isInt(i&^5);
+ asInt(5&^i);
+ isInt(5&^i);
+ asInt(i&^i);
+ isInt(i&^i);
+ i&^=2;
+ asInt(i|5);
+ isInt(i|5);
+ asInt(5|i);
+ isInt(5|i);
+ asInt(i|i);
+ isInt(i|i);
+ i|=2;
+ asInt(i^5);
+ isInt(i^5);
+ asInt(5^i);
+ isInt(5^i);
+ asInt(i^i);
+ isInt(i^i);
+ i^=2;
+ asInt(i<<4);
+ isInt(i<<4);
+ i<<=2;
+ asInt(i>>4);
+ isInt(i>>4);
+ i>>=2;
+ asInt(i);
+ isInt(i);
+ asInt(0);
+ asInt(Int(0));
+ isInt(Int(0));
+ i = 10;
+ asInt(*&i);
+ isInt(*&i);
+ asInt(23);
+ asInt(Int(f));
+ isInt(Int(f));
+
+ asMap(m);
+ isMap(m);
+ asMap(nil);
+ m = nil;
+ asMap(make(Map));
+ isMap(make(Map));
+ asMap(*&m);
+ isMap(*&m);
+ asMap(Map(nil));
+ isMap(Map(nil));
+ asMap(Map{});
+ isMap(Map{});
+
+ asSlice(slice);
+ isSlice(slice);
+ asSlice(make(Slice, 5));
+ isSlice(make(Slice, 5));
+ asSlice([]byte{1,2,3});
+ asSlice([]byte{1,2,3}[0:2]);
+ asSlice(slice[0:4]);
+ isSlice(slice[0:4]);
+ asSlice(slice[3:8]);
+ isSlice(slice[3:8]);
+ asSlice(nil);
+ asSlice(Slice(nil));
+ isSlice(Slice(nil));
+ slice = nil;
+ asSlice(Slice{1,2,3});
+ isSlice(Slice{1,2,3});
+ asSlice(Slice{});
+ isSlice(Slice{});
+ asSlice(*&slice);
+ isSlice(*&slice);
+
+ asString(str);
+ isString(str);
+ asString(str+"a");
+ isString(str+"a");
+ asString("a"+str);
+ isString("a"+str);
+ asString(str+str);
+ isString(str+str);
+ str += "a";
+ str += str;
+ asString(String('a'));
+ isString(String('a'));
+ asString(String(slice));
+ isString(String(slice));
+ asString(String([]byte(nil)));
+ isString(String([]byte(nil)));
+ asString("hello");
+ asString(String("hello"));
+ isString(String("hello"));
+ str = "hello";
+ isString(str);
+ asString(*&str);
+ isString(*&str);
+}