[m-rev.] diff: fix bug in error messages

[Mark Brown]

On 19-May-2005, Julien Fischer <juliensf at cs.mu.OZ.AU> wrote:
> 
> On Sun, 8 May 2005, Mark Brown wrote:
> 
> > Hi,
> >
> > This fixes a bug that was reported by Rob Moss a while ago.
> >
> > Cheers,
> > Mark.
> >
> > Estimated hours taken: 0.5
> > Branches: main, release
> >
> > compiler/module_qual.m:
> > 	Check for variables used as constructors when module qualifying types
> > 	and insts.  In both cases this is currently illegal, so we report a
> > 	more sensible error message than we would otherwise get.
> >
> > compiler/prog_type.m:
> > 	Export a test to check if a type uses a variable as a constructor.
> >
> > tests/invalid/Mmakefile:
> > tests/invalid/kind.err_exp:
> > tests/invalid/kind.m:
> > 	Test case.
> >
> 
> This change has broken code like that in the attached example where
> we define a type like the following:
> 
> 	:- type '' ---> ''.
> 
> and then try to use it.

Hmm.  It also "breaks" the following code:

	:- type ''(T) ---> f(T).
	:- func bar(int) = ''(int).
	bar(N) = f(N).

But this code should be illegal, since according to the reference manual:

| A higher-order term is equivalent to a simple compound term whose functor
| is the empty name, and whose arguments are the closure term followed by
| the argument terms of the higher-order term.

therefore the definition of baz is equivalent to:

	:- func baz(int) = int.
	baz(N) = g(N).

which is a type error.

It also breaks:

	:- type ''(T, U) ---> g(T, U).
	:- func baz(int) = ''(int, int).
	baz(N) = g(N, N).

Here the definition of baz is equivalent to:

	:- func baz(int) = int(int).
	baz(N) = g(N, N).

which doesn't make sense at all.

(Note that the error reported for the bar/1 case is wrong, since the
compiler objects to the type expression ''(int) but does not object to
the type definition for ''(T).  The error message for baz/1 is okay.)

So the question is, should

	:- type '' ---> ''.

be legal?  In value expressions the term '' is a builtin that is is
equivalent to 'apply', since it takes the first (higher-order) argument
and applies the remaining arguments.  When we have higher order types
(i.e. constructor classes, etc), the type expression '' should be the
type equivalent of 'apply'.

So I think the answer to the question is no, the above type should not
be legal, and the funny_type test case should be changed or removed.

Are there any dissenting views?  If not, I shall look into fixing the
errors that are reported, and also clarifying the reference manual.

Cheers,
Mark.

--------------------------------------------------------------------------
mercury-reviews mailing list
post:  mercury-reviews at cs.mu.oz.au
administrative address: owner-mercury-reviews at cs.mu.oz.au
unsubscribe: Address: mercury-reviews-request at cs.mu.oz.au Message: unsubscribe
subscribe:   Address: mercury-reviews-request at cs.mu.oz.au Message: subscribe
--------------------------------------------------------------------------