The change to assign.go is because the gcc testsuite fails to
handle .* in a normal way: it matches against the entire
compiler output, not just a single line.
assign.go:15:6: error: incompatible types in assignment (implicit assignment of 'sync.Mutex' hidden field 'key')
assign.go:19:6: error: incompatible types in assignment (implicit assignment of 'sync.Mutex' hidden field 'key')
assign.go:23:6: error: incompatible types in assignment (implicit assignment of 'sync.Mutex' hidden field 'key')
assign.go:27:6: error: incompatible types in assignment (implicit assignment of 'sync.Mutex' hidden field 'key')
chan/perm.go:14:5: error: incompatible types in assignment
chan/perm.go:15:5: error: incompatible types in assignment
chan/perm.go:16:6: error: incompatible types in assignment
chan/perm.go:17:6: error: incompatible types in assignment
chan/perm.go:24:7: error: invalid send on receive-only channel
chan/perm.go:25:12: error: invalid send on receive-only channel
chan/perm.go:31:4: error: invalid receive on send-only channel
chan/perm.go:32:9: error: invalid receive on send-only channel
chan/perm.go:38:2: error: invalid send on receive-only channel
chan/perm.go:42:2: error: invalid receive on send-only channel
initializerr.go:14:17: error: reference to undefined variable 'X'
initializerr.go:14:19: error: mixture of field and value initializers
initializerr.go:15:26: error: duplicate value for field 'Y'
initializerr.go:16:10: error: too many values in struct composite literal
initializerr.go:18:19: error: index expression is not integer constant
initializerr.go:17:11: error: too many elements in composite literal
R=rsc
DELTA=12 (0 added, 0 deleted, 12 changed)
OCL=29657
CL=29665
this is not a user-visible change.
before, all interface values were
struct Itype {
Sigt *type;
Sigi *inter;
void *method[n];
}
struct Iface {
void *addr;
Itype *itype;
}
the itype is basically a vtable, but it's unnecessary
if the static type is interface{ }.
for interface values with static type empty, the
new representation is
struct Eface {
void *addr;
Sigt *type;
}
this complicates the code somewhat, but
it reduces the number of Itypes that
have to be computed and cached,
it opens up opportunities to avoid function
calls in a few common cases,
and it will make it possible to lay out
interface{} values at compile time,
which i think i'll need for the new reflection.
R=ken
OCL=28701
CL=29121
gives an type mismatch error, although both values appear to
have the same type.
R=ken,rsc
DELTA=23 (23 added, 0 deleted, 0 changed)
OCL=28786
CL=28805
if both types are named, they must be
the same type (arising from the same
declaration).
R=r,gri
DELTA=44 (21 added, 4 deleted, 19 changed)
OCL=28436
CL=28577
replace "shape error across CALL" with more information.
x.go:7: not enough arguments to CALL
a int, b int
int
x.go:10: assignment count mismatch: 3 = 2
x.go:12: too many arguments to RETURN
[no arguments expected]
int, int, int
also leave type alone after conversion failure,
for later errors:
bug049.go:6: cannot convert nil constant to string
bug049.go:6: illegal types for operand: EQ
string
nil # this used to be blank
R=ken
OCL=28405
CL=28407
you should be able to convert a pointer to an array to a
slice, you should not be able to convert an array to a slice.
Currently 6g works the other way around.
R=ken,rsc
DELTA=17 (17 added, 0 deleted, 0 changed)
OCL=28033
CL=28067
add test for string range.
test has minor failure: after loop the index == len(s); should be len(s)-1
in this case. according to spec, vars are left at position at last
iteration.
R=ken,rsc
DELTA=259 (161 added, 96 deleted, 2 changed)
OCL=27343
CL=27343
if T has pointer methods. this is just a heuristic
but it catches the problem robert ran into and
lets me put the larger interface issues aside for
now. found one bug in pretty.
R=ken
OCL=26141
CL=26141
make f(g()) work when g returns multiple
args with names different than f expects.
func swap(a, b int) (c, d int) {
return b, a
}
swap(swap(1,2))
R=ken
OCL=24474
CL=24476
when it should not be. I couldn't get this any simpler; the
error seems to have to do with the order of the imports in
bug2.go.
R=rsc
DELTA=26 (26 added, 0 deleted, 0 changed)
OCL=23450
CL=23482
implement hiding lowercase methods m in
signatures by adding in a hash of the package name
to the type hash code.
remove remaining checks for internally-generated _ names:
they are all gone.
R=ken
OCL=23236
CL=23238
fix bug in run that was missing output.
make run warn about tests in bugs/ that succeed with no output
(should be moved to fixedbugs/).
R=r
DELTA=21 (18 added, 0 deleted, 3 changed)
OCL=19381
CL=19381
variable may only be named after the complete declaration,
including the initialization statements.
R=gri
DELTA=61 (16 added, 45 deleted, 0 changed)
OCL=19343
CL=19376
recognize methods for a variable whose type is a named type
which is a pointer type. Add bug117 to test this case.
R=r
DELTA=24 (22 added, 0 deleted, 2 changed)
OCL=18547
CL=18554
sigi and sigt:
sys·sigi_inter -> sigi·inter
sys·sigt_int -> sigt·int
Package·sigt_Type -> sigt·Package.Type
local type T in file x.go T_x -> T·x
second one T_x_1 -> T·x·1
method names M on T T_M -> T·M
correctly handle local embedded types
init functions are the only place left that use underscores
R=ken
OCL=18377
CL=18377
object has a value of type "int", it should not automatically
convert to type "int32". That is, the type alias "int" should
be regarded as having been defined as though "type int int32"
appeared outside of the package, and as therefore being a
different type from "int32".
R=ken
DELTA=21 (20 added, 0 deleted, 1 changed)
OCL=17587
CL=17842
* print int as int, not P.int
* write type info for non-exported types
in its own new section.
ar:
skip over rest of line after $$
R=ken
OCL=17568
CL=17568
the comment talked about printing, but now
t->recur is only used for typehash.
in typehash it is important to compute different
hashes for the different basic types.
add test that makes sure an interface { X() int8 }
cannot be used as interface { X() int64 }
R=ken
OCL=17396
CL=17396
- pointer to interface cannot have methods
- record type names for better runtime error
R=r,ken
DELTA=85 (80 added, 0 deleted, 5 changed)
OCL=16658
CL=16722
type T struct {
next *T
}
and
type T *struct {
next T
}
are valid without needing forward declarations.
add "type T struct" syntax for forward struct declarations.
add "type T interface" syntax, but commented out
(need to fix semicolons first)
R=ken
DELTA=452 (259 added, 115 deleted, 78 changed)
OCL=16580
CL=16584
package flag
export type flag.Flag struct { name flag.string; usage flag.string; \
value flag.Value; next *flag.Flag }
type flag.string string
type flag.Value interface { AsBool () (? *flag.BoolValue); \
AsInt () (? *flag.IntValue); AsString () (? *flag.StringValue); \
IsBool () (? flag.bool); IsInt () (? flag.bool); IsString () (? flag.bool); \
Str () (? flag.string); ValidValue (str flag.string) (? flag.bool) }
type flag.BoolValue struct { val flag.bool; p *flag.bool }
type flag.IntValue struct { val flag.int64; p *flag.int64 }
type flag.StringValue struct { val flag.string; p *flag.string }
type flag.bool bool
func (e *flag.StringValue) AsBool () (? *flag.BoolValue)
func (e *flag.StringValue) AsInt () (? *flag.IntValue)
...
the \ continuations are for this message, not real.
changed delimiter for import from (( )) to $$ $$.
replaced mksys.bash with mksys.c
changed sys.go to use leading export,
fake package name is now SYS not foop
don't always require ; on forward func decls
R=ken,r
DELTA=1827 (446 added, 1083 deleted, 298 changed)
OCL=16433
CL=16463
