Thread overview | |||||||||
---|---|---|---|---|---|---|---|---|---|
|
November 10, 2011 Add pragma(error) and pragma(warning) to the language. | ||||
---|---|---|---|---|
| ||||
I'm currently writing some template based code and there are situations, when I want to issue warnings or errors to users of my code. I know of pragma(msg), but the output will be formatted differently from the normal compiler warnings / errors. This is bad for tool integration and the messages will likely not catch the eye of a normal user. Therefore I propose to add two pragmas pragma(error) and pragma(warning) to the core language, which work just like pragma(msg), but will format the message the way, the compiler would format its own error messages or warnings. pragma(error) should cause a real compile error, too. What do you think? |
November 10, 2011 Re: Add pragma(error) and pragma(warning) to the language. | ||||
---|---|---|---|---|
| ||||
Posted in reply to Tobias Pankrath | How would pragma(error) differ from "static assert(false, errorMessageHere)"?
Tobias Pankrath wrote:
> I'm currently writing some template based code and there are situations, when I want to issue warnings or errors to users of my code.
>
> I know of pragma(msg), but the output will be formatted differently from the normal compiler warnings / errors. This is bad for tool integration and the messages will likely not catch the eye of a normal user.
>
> Therefore I propose to add two pragmas pragma(error) and pragma(warning)
> to the core language, which work just like pragma(msg), but will format
> the message the way, the compiler would format
> its own error messages or warnings.
>
> pragma(error) should cause a real compile error, too.
>
> What do you think?
|
November 10, 2011 Re: Add pragma(error) and pragma(warning) to the language. | ||||
---|---|---|---|---|
| ||||
Posted in reply to Justin Whear | Justin Whear wrote:
> How would pragma(error) differ from "static assert(false,
> errorMessageHere)"?
>
It wouldn't. I was just not aware of this possibility.
|
November 10, 2011 Re: Add pragma(error) and pragma(warning) to the language. | ||||
---|---|---|---|---|
| ||||
Posted in reply to Justin Whear | On 11/10/2011 08:12 PM, Justin Whear wrote:
> How would pragma(error) differ from "static assert(false,
> errorMessageHere)"?
>
>
static assert explains that the error occured because of a static assertion failure, pragma(error) would not do such a thing.
@topic: +1.
|
November 10, 2011 Re: Add pragma(error) and pragma(warning) to the language. | ||||
---|---|---|---|---|
| ||||
Posted in reply to Tobias Pankrath | On 11/10/2011 2:08 PM, Tobias Pankrath wrote:
> I'm currently writing some template based code and there are
> situations, when I want to issue warnings or errors to users of my code.
>
> I know of pragma(msg), but the output will be formatted differently from the
> normal compiler warnings / errors. This is bad for tool integration and the
> messages will likely not catch the eye of a normal user.
>
> Therefore I propose to add two pragmas pragma(error) and pragma(warning) to
> the core language, which work just like pragma(msg), but will format the
> message the way, the compiler would format
> its own error messages or warnings.
>
> pragma(error) should cause a real compile error, too.
>
> What do you think?
I'm not against this idea, but I'd prefer that actual compiler warnings & errors would be distinguishable from those thrown by code.
|
November 10, 2011 Re: Add pragma(error) and pragma(warning) to the language. | ||||
---|---|---|---|---|
| ||||
Posted in reply to Xinok | On 11/10/2011 08:36 PM, Xinok wrote:
> On 11/10/2011 2:08 PM, Tobias Pankrath wrote:
>> I'm currently writing some template based code and there are
>> situations, when I want to issue warnings or errors to users of my code.
>>
>> I know of pragma(msg), but the output will be formatted differently
>> from the
>> normal compiler warnings / errors. This is bad for tool integration
>> and the
>> messages will likely not catch the eye of a normal user.
>>
>> Therefore I propose to add two pragmas pragma(error) and
>> pragma(warning) to
>> the core language, which work just like pragma(msg), but will format the
>> message the way, the compiler would format
>> its own error messages or warnings.
>>
>> pragma(error) should cause a real compile error, too.
>>
>> What do you think?
>
> I'm not against this idea, but I'd prefer that actual compiler warnings
> & errors would be distinguishable from those thrown by code.
They are because the compiler gives line information (and a good error message will normally be as specific as to give a good indication that it was thrown by code anyway).
|
November 11, 2011 Re: Add pragma(error) and pragma(warning) to the language. | ||||
---|---|---|---|---|
| ||||
Posted in reply to Timon Gehr | Separating compiler built-in and user-space solutions is a bad idea, IMO.
The evolution of programming languages clearly show, that there is
less and less magic in the air as they develop.
Ultimately, programming languages will be reduced to a tiny tiny core
and a giant ball of user-space support layers.
On Fri, Nov 11, 2011 at 12:23 AM, Timon Gehr <timon.gehr@gmx.ch> wrote:
> On 11/10/2011 08:36 PM, Xinok wrote:
>>
>> On 11/10/2011 2:08 PM, Tobias Pankrath wrote:
>>>
>>> I'm currently writing some template based code and there are situations, when I want to issue warnings or errors to users of my code.
>>>
>>> I know of pragma(msg), but the output will be formatted differently
>>> from the
>>> normal compiler warnings / errors. This is bad for tool integration
>>> and the
>>> messages will likely not catch the eye of a normal user.
>>>
>>> Therefore I propose to add two pragmas pragma(error) and
>>> pragma(warning) to
>>> the core language, which work just like pragma(msg), but will format the
>>> message the way, the compiler would format
>>> its own error messages or warnings.
>>>
>>> pragma(error) should cause a real compile error, too.
>>>
>>> What do you think?
>>
>> I'm not against this idea, but I'd prefer that actual compiler warnings & errors would be distinguishable from those thrown by code.
>
> They are because the compiler gives line information (and a good error message will normally be as specific as to give a good indication that it was thrown by code anyway).
>
|
Copyright © 1999-2021 by the D Language Foundation