HPCC-10977 Categorise the code generator warnings

Signed-off-by: Gavin Halliday <gavin.halliday@lexisnexis.com>

ecl/hql/hqlerror.cpp

@@ -19,16 +19,83 @@
 #include "hqlerror.hpp"
 #include "hqlerrors.hpp"
 
+//---------------------------------------------------------------------------------------------------------------------
+
+ErrorSeverity getSeverity(IAtom * name)
+{
+    if (name == failAtom)
+        return SeverityFatal;
+    if (name == errorAtom)
+        return SeverityError;
+    if (name == warningAtom)
+        return SeverityWarning;
+    if (name == ignoreAtom)
+        return SeverityIgnore;
+    if (name == logAtom)
+        return SeverityInfo;
+    return SeverityUnknown;
+}
+
+ErrorSeverity queryDefaultSeverity(WarnErrorCategory category)
+{
+    if (category == CategoryError)
+        return SeverityFatal;
+    if (category == CategoryInformation)
+        return SeverityInfo;
+    return SeverityWarning;
+}
+
+WarnErrorCategory getCategory(const char * category)
+{
+    if (strieq(category, "all"))
+        return CategoryAll;
+    if (strieq(category, "cast"))
+        return CategoryCast;
+    if (strieq(category, "confuse"))
+        return CategoryConfuse;
+    if (strieq(category, "deprecated"))
+        return CategoryDeprecated;
+    if (strieq(category, "efficiency"))
+        return CategoryEfficiency;
+    if (strieq(category, "future"))
+        return CategoryFuture;
+    if (strieq(category, "ignored"))
+        return CategoryIgnored;
+    if (strieq(category, "index"))
+        return CategoryIndex;
+    if (strieq(category, "info"))
+        return CategoryInformation;
+    if (strieq(category, "mistype"))
+        return CategoryMistyped;
+    if (strieq(category, "syntax"))
+        return CategorySyntax;
+    if (strieq(category, "unusual"))
+        return CategoryUnusual;
+    if (strieq(category, "unexpected"))
+        return CategoryUnexpected;
+    return CategoryUnknown;
+}
+
+ErrorSeverity getCheckSeverity(IAtom * name)
+{
+    ErrorSeverity severity = getSeverity(name);
+    assertex(severity != SeverityUnknown);
+    return severity;
+}
+
+
+//---------------------------------------------------------------------------------------------------------------------
+
 class HQL_API CECLError : public CInterfaceOf<IECLError>
 {
 public:
-    CECLError(ErrorSeverity _severity, int _no, const char* _msg, const char* _filename, int _lineno, int _column, int _position);
+    CECLError(WarnErrorCategory _category,ErrorSeverity _severity, int _no, const char* _msg, const char* _filename, int _lineno, int _column, int _position);
 
     virtual int             errorCode() const { return no; }
     virtual StringBuffer &  errorMessage(StringBuffer & ret) const { return ret.append(msg); }
     virtual MessageAudience errorAudience() const { return MSGAUD_user; }
     virtual const char* getFilename() const { return filename; }
-    virtual WarnErrorCategory getCategory() const { return CategoryUnknown; }
+    virtual WarnErrorCategory getCategory() const { return category; }
     virtual int getLine() const { return lineno; }
     virtual int getColumn() const { return column; }
     virtual int getPosition() const { return position; }
@@ -38,6 +105,7 @@ public:
 
 protected:
     ErrorSeverity severity;
+    WarnErrorCategory category;
     int no;
     StringAttr msg;
     StringAttr filename;
@@ -46,8 +114,8 @@ protected:
     int position;
 };
 
-CECLError::CECLError(ErrorSeverity _severity, int _no, const char* _msg, const char* _filename, int _lineno, int _column, int _position):
-  severity(_severity), msg(_msg), filename(_filename)
+CECLError::CECLError(WarnErrorCategory _category, ErrorSeverity _severity, int _no, const char* _msg, const char* _filename, int _lineno, int _column, int _position):
+  category(_category),severity(_severity), msg(_msg), filename(_filename)
 {
     no = _no;
     lineno = _lineno;
@@ -70,14 +138,14 @@ StringBuffer& CECLError::toString(StringBuffer& buf) const
 
 IECLError * CECLError::cloneSetSeverity(ErrorSeverity newSeverity) const
 {
-    return new CECLError(newSeverity,
+    return new CECLError(category, newSeverity,
                          errorCode(), msg, filename,
                          getLine(), getColumn(), getPosition());
 }
 
-extern HQL_API IECLError *createECLError(ErrorSeverity severity, int errNo, const char *msg, const char * filename, int lineno, int column, int pos)
+extern HQL_API IECLError *createECLError(WarnErrorCategory category, ErrorSeverity severity, int errNo, const char *msg, const char * filename, int lineno, int column, int pos)
 {
-    return new CECLError(severity,errNo,msg,filename,lineno,column,pos);
+    return new CECLError(category,severity,errNo,msg,filename,lineno,column,pos);
 }
 
 //---------------------------------------------------------------------------------------------------------------------
@@ -88,9 +156,10 @@ void IErrorReceiver::reportError(int errNo, const char *msg, const char *filenam
     report(err);
 }
 
-void IErrorReceiver::reportWarning(int warnNo, const char *msg, const char *filename, int lineno, int column, int position)
+void IErrorReceiver::reportWarning(WarnErrorCategory category, int warnNo, const char *msg, const char *filename, int lineno, int column, int position)
 {
-    Owned<IECLError> warn = createECLError(SeverityWarning,warnNo,msg,filename,lineno,column,position);
+    ErrorSeverity severity = queryDefaultSeverity(category);
+    Owned<IECLError> warn = createECLError(category, severity,warnNo,msg,filename,lineno,column,position);
     report(warn);
 }
 
@@ -332,18 +401,18 @@ void checkEclVersionCompatible(Shared<IErrorReceiver> & errors, const char * ecl
             if (major != LANGUAGE_VERSION_MAJOR)
             {
                 VStringBuffer msg("Mismatch in major version number (%s v %s)", eclVersion, LANGUAGE_VERSION);
-                errors->reportWarning(HQLERR_VersionMismatch, msg.str(), NULL, 0, 0, 0);
+                errors->reportWarning(CategoryUnexpected, HQLERR_VersionMismatch, msg.str(), NULL, 0, 0, 0);
             }
             else if (minor != LANGUAGE_VERSION_MINOR)
             {
                 VStringBuffer msg("Mismatch in minor version number (%s v %s)", eclVersion, LANGUAGE_VERSION);
-                errors->reportWarning(HQLERR_VersionMismatch, msg.str(), NULL, 0, 0, 0);
+                errors->reportWarning(CategoryUnexpected, SeverityInfo, msg.str(), NULL, 0, 0, 0);
             }
             else if (subminor != LANGUAGE_VERSION_SUB)
             {
                 //This adds the warning if any other warnings occur.
                 VStringBuffer msg("Mismatch in subminor version number (%s v %s)", eclVersion, LANGUAGE_VERSION);
-                Owned<IECLError> warning = createECLError(SeverityWarning, HQLERR_VersionMismatch, msg.str(), NULL, 0, 0);
+                Owned<IECLError> warning = createECLError(CategoryUnexpected, SeverityInfo, HQLERR_VersionMismatch, msg.str(), NULL, 0, 0);
                 errors.setown(new ErrorInserter(*errors, warning));
             }
         }

ecl/hql/hqlerror.hpp

@@ -39,6 +39,8 @@ inline bool isFatal(ErrorSeverity severity) { return severity == SeverityFatal;
 //TBD in a separate commit - add support for warnings to be associated with different categories
 enum WarnErrorCategory
 {
+    CategoryInformation,// Some kind of information [default severity information]
+
     CategoryCast,       // Suspicious casts between types or out of range values
     CategoryConfuse,    // Likely to cause confusion
     CategoryDeprecated, // deprecated features or syntax
@@ -51,7 +53,7 @@ enum WarnErrorCategory
     CategoryUnusual,    // Not strictly speaking an error, but highly unusual and likely to be a mistake
     CategoryUnexpected, // Code that could be correct, but has the potential for unexpected behaviour
 
-    CategoryError,
+    CategoryError,      // Typically severity fatal
     CategoryAll,
     CategoryUnknown,
     CategoryMax,
@@ -81,7 +83,7 @@ interface HQL_API IErrorReceiver : public IInterface
 
     //global helper functions
     void reportError(int errNo, const char *msg, const char *filename, int lineno, int column, int pos);
-    void reportWarning(int warnNo, const char *msg, const char *filename, int lineno, int column, int pos);
+    void reportWarning(WarnErrorCategory category, int warnNo, const char *msg, const char *filename, int lineno, int column, int pos);
 };
 
 typedef IArrayOf<IECLError> IECLErrorArray;
@@ -153,10 +155,17 @@ private:
 
 //---------------------------------------------------------------------------------------------------------------------
 
-extern HQL_API IECLError *createECLError(ErrorSeverity severity, int errNo, const char *msg, const char *filename, int lineno=0, int column=0, int pos=0);
+ErrorSeverity queryDefaultSeverity(WarnErrorCategory category);
+WarnErrorCategory getCategory(const char * category);
+ErrorSeverity getSeverity(IAtom * name);
+ErrorSeverity getCheckSeverity(IAtom * name);
+
+//---------------------------------------------------------------------------------------------------------------------
+
+extern HQL_API IECLError *createECLError(WarnErrorCategory category, ErrorSeverity severity, int errNo, const char *msg, const char *filename, int lineno=0, int column=0, int pos=0);
 inline IECLError * createECLError(int errNo, const char *msg, const char *filename, int lineno=0, int column=0, int pos=0)
 {
-    return createECLError(SeverityFatal, errNo, msg, filename, lineno, column, pos);
+    return createECLError(CategoryError, SeverityFatal, errNo, msg, filename, lineno, column, pos);
 }
 extern HQL_API void reportErrors(IErrorReceiver & receiver, IECLErrorArray & errors);
 void HQL_API reportErrorVa(IErrorReceiver * errors, int errNo, const ECLlocation & loc, const char* format, va_list args);

ecl/hql/hqlexpr.cpp

@@ -8079,7 +8079,7 @@ IHqlExpression *CHqlRemoteScope::lookupSymbol(IIdAtom * searchName, unsigned loo
     if (repositoryFlags&ob_sandbox)
     {
         if (ctx.errs)
-            ctx.errs->reportWarning(WRN_DEFINITION_SANDBOXED,"Definition is sandboxed",filename,0,0,0);
+            ctx.errs->reportWarning(CategoryInformation,WRN_DEFINITION_SANDBOXED,"Definition is sandboxed",filename,0,0,0);
     }
 
     if (!(newSymbol->isExported() || (lookupFlags & LSFsharedOK)))

ecl/hql/hqlgram2.cpp

@@ -264,23 +264,13 @@ bool HqlGramCtx::hasAnyActiveParameters()
 }
 
 
-static IECLError * createErrorVA(ErrorSeverity severity, int errNo, const ECLlocation & pos, const char* format, va_list args)
+static IECLError * createErrorVA(WarnErrorCategory category, ErrorSeverity severity, int errNo, const ECLlocation & pos, const char* format, va_list args)
 {
     StringBuffer msg;
     msg.valist_appendf(format, args);
-    return createECLError(severity, errNo, msg.str(), pos.sourcePath->str(), pos.lineno, pos.column, pos.position);
+    return createECLError(category, severity, errNo, msg.str(), pos.sourcePath->str(), pos.lineno, pos.column, pos.position);
 }
 
-static IECLError * createError(ErrorSeverity severity, int errNo, const ECLlocation & pos, const char* format, ...)
-{
-    va_list args;
-    va_start(args, format);
-    IECLError * error = createErrorVA(severity, errNo, pos, format, args);
-    va_end(args);
-    return error;
-}
-
-
 void HqlGram::gatherActiveParameters(HqlExprCopyArray & target)
 {
     ForEachItemIn(i2, defineScopes)
@@ -5803,7 +5793,7 @@ void HqlGram::reportErrorUnexpectedX(const attribute& errpos, IAtom * unexpected
 
 void HqlGram::doReportWarning(int warnNo, const char *msg, const char *filename, int lineno, int column, int pos)
 {
-    Owned<IECLError> error = createECLError(SeverityWarning, warnNo, msg, filename, lineno, column, pos);
+    Owned<IECLError> error = createECLError(CategoryUnknown, SeverityWarning, warnNo, msg, filename, lineno, column, pos);
     report(error);
 }
 
@@ -5829,7 +5819,7 @@ void HqlGram::reportMacroExpansionPosition(int errNo, HqlLex * lexer, bool isErr
 
 void HqlGram::reportErrorVa(int errNo, const ECLlocation & pos, const char* format, va_list args)
 {
-    Owned<IECLError> error = createErrorVA(SeverityFatal, errNo, pos, format, args);
+    Owned<IECLError> error = createErrorVA(CategoryError, SeverityFatal, errNo, pos, format, args);
     report(error);
 }
 
@@ -5848,7 +5838,7 @@ void HqlGram::reportWarning(int warnNo, const ECLlocation & pos, const char* for
     {
         va_list args;
         va_start(args, format);
-        Owned<IECLError> error = createErrorVA(SeverityWarning, warnNo, pos, format, args);
+        Owned<IECLError> error = createErrorVA(CategoryUnknown, SeverityWarning, warnNo, pos, format, args);
         va_end(args);
 
         report(error);
@@ -5862,7 +5852,7 @@ void HqlGram::reportWarning(ErrorSeverity severity, int warnNo, const ECLlocatio
         StringBuffer msg;
         va_list args;
         va_start(args, format);
-        Owned<IECLError> error = createErrorVA(severity, warnNo, pos, format, args);
+        Owned<IECLError> error = createErrorVA(CategoryUnknown, severity, warnNo, pos, format, args);
         va_end(args);
 
         report(error);
@@ -5874,7 +5864,7 @@ void HqlGram::reportWarningVa(int warnNo, const attribute& a, const char* format
     const ECLlocation & pos = a.pos;
     if (errorHandler && !errorDisabled)
     {
-        Owned<IECLError> error = createErrorVA(SeverityWarning, warnNo, pos, format, args);
+        Owned<IECLError> error = createErrorVA(CategoryUnknown, SeverityWarning, warnNo, pos, format, args);
         report(error);
     }
 }
@@ -8954,7 +8944,7 @@ IHqlExpression * HqlGram::associateSideEffects(IHqlExpression * expr, const ECLl
             {
                 if (expr->isScope())
                 {
-                    Owned<IECLError> error = createError(SeverityError, ERR_RESULT_IGNORED_SCOPE, errpos, "Cannot associate a side effect with a module - action will be lost");
+                    Owned<IECLError> error = createECLError(CategorySyntax, SeverityError, ERR_RESULT_IGNORED_SCOPE, "Cannot associate a side effect with a module - action will be lost", errpos.sourcePath->str(), errpos.lineno, errpos.column, errpos.position);
                     //Unusual processing.  Create a warning and save it in the parse context
                     //The reason is that this error is reporting "the associated side-effects will be lost" - but
                     //the same will apply to the warning, and if it's lost there will be no way to report it later...

ecl/hql/hqlparse.cpp

@@ -101,7 +101,7 @@ public:
     virtual StringBuffer& demangle(const char* mangled, StringBuffer& demangled) { return ::mangle(m_lookupContext.errs,mangled,demangled,true); }
 
     virtual void reportError(int errNo,const char* format,...);
-    virtual void reportWarning(int warnNo,const char* format,...);
+    virtual void reportWarning(WarnErrorCategory category, int warnNo,const char* format,...);
 };
 
 void CTemplateContext::reportError(int errNo,const char* format,...)
@@ -117,7 +117,7 @@ void CTemplateContext::reportError(int errNo,const char* format,...)
     }
 }
 
-void CTemplateContext::reportWarning(int warnNo,const char* format,...)
+void CTemplateContext::reportWarning(WarnErrorCategory category,int warnNo,const char* format,...)
 {
     if (m_lookupContext.errs)
     {
@@ -125,7 +125,7 @@ void CTemplateContext::reportWarning(int warnNo,const char* format,...)
         va_start(args, format);
         StringBuffer msg;
         msg.valist_appendf(format,args);
-        m_lookupContext.errs->reportWarning(warnNo,msg.str(),NULL,m_startLine,m_startCol,0);
+        m_lookupContext.errs->reportWarning(category,warnNo,msg.str(),NULL,m_startLine,m_startCol,0);
         va_end(args);
     }
 }

ecl/hql/hqlutil.cpp

@@ -5770,7 +5770,7 @@ void TempTableTransformer::reportWarning(IHqlExpression * location, int code,con
     va_start(args, format);
     errorMsg.valist_appendf(format, args);
     va_end(args);
-    errorProcessor.reportWarning(code, errorMsg.str(), where->sourcePath->str(), where->lineno, where->column, where->position);
+    errorProcessor.reportWarning(CategoryUnknown, code, errorMsg.str(), where->sourcePath->str(), where->lineno, where->column, where->position);
 }
 
 IHqlExpression *getDictionaryKeyRecord(IHqlExpression *record)
@@ -6450,57 +6450,6 @@ void gatherGraphReferences(HqlExprCopyArray & graphs, IHqlExpression * value, bo
 
 //---------------------------------------------------------------------------
 
-ErrorSeverity getSeverity(IAtom * name)
-{
-    if (name == failAtom)
-        return SeverityFatal;
-    if (name == errorAtom)
-        return SeverityError;
-    if (name == warningAtom)
-        return SeverityWarning;
-    if (name == ignoreAtom)
-        return SeverityIgnore;
-    if (name == logAtom)
-        return SeverityInfo;
-    return SeverityUnknown;
-}
-
-WarnErrorCategory getCategory(const char * category)
-{
-    if (strieq(category, "all"))
-        return CategoryAll;
-    if (strieq(category, "cast"))
-        return CategoryCast;
-    if (strieq(category, "confuse"))
-        return CategoryConfuse;
-    if (strieq(category, "deprecated"))
-        return CategoryDeprecated;
-    if (strieq(category, "efficiency"))
-        return CategoryEfficiency;
-    if (strieq(category, "future"))
-        return CategoryFuture;
-    if (strieq(category, "ignored"))
-        return CategoryIgnored;
-    if (strieq(category, "index"))
-        return CategoryIndex;
-    if (strieq(category, "mistype"))
-        return CategoryMistyped;
-    if (strieq(category, "syntax"))
-        return CategorySyntax;
-    if (strieq(category, "unusual"))
-        return CategoryUnusual;
-    if (strieq(category, "unexpected"))
-        return CategoryUnexpected;
-    return CategoryUnknown;
-}
-
-static ErrorSeverity getCheckSeverity(IAtom * name)
-{
-    ErrorSeverity severity = getSeverity(name);
-    assertex(severity != SeverityUnknown);
-    return severity;
-}
-
 static ErrorSeverity getWarningAction(unsigned errorCode, const HqlExprArray & overrides, unsigned first, ErrorSeverity defaultSeverity)
 {
     //warnings are assumed to be infrequent, so don't worry about efficiency here.

ecl/hql/hqlxmldb.hpp

@@ -20,6 +20,7 @@
 #include "jiface.hpp"
 #include "jiter.hpp"
 #include "hql.hpp"
+#include "hqlerror.hpp"
 
 //-----------------------------------------------------------------------------
 // Class Definitions
@@ -58,7 +59,7 @@ interface ITemplateContext : public IInterface
     virtual StringBuffer& demangle(const char* mangled, StringBuffer& demangled) = 0;
 
     virtual void reportError(int errNo,const char* format,...) __attribute__((format(printf, 3, 4))) = 0;
-    virtual void reportWarning(int warnNo,const char* format,...) __attribute__((format(printf, 3, 4))) = 0;      
+    virtual void reportWarning(WarnErrorCategory category, int warnNo,const char* format,...) __attribute__((format(printf, 4, 5))) = 0;
 
     // Ideally, the user has no need to use this.
     virtual IEclRepository* queryDataServer() = 0;

ecl/hqlcpp/hqlcpp.cpp

@@ -2041,9 +2041,9 @@ void HqlCppTranslator::doReportWarning(IHqlExpression * location, unsigned id, c
     if (!location)
         location = queryActiveActivityLocation();
     if (location)
-        warnError.setown(createECLError(SeverityWarning, id, msg, location->querySourcePath()->str(), location->getStartLine(), location->getStartColumn(), 0));
+        warnError.setown(createECLError(CategoryUnknown, SeverityWarning, id, msg, location->querySourcePath()->str(), location->getStartLine(), location->getStartColumn(), 0));
     else
-        warnError.setown(createECLError(SeverityWarning, id, msg, NULL, 0, 0, 0));
+        warnError.setown(createECLError(CategoryUnknown, SeverityWarning, id, msg, NULL, 0, 0, 0));
 
     errorProcessor->report(warnError);
 }

ecl/hqlcpp/hqlttcpp.cpp

@@ -9059,7 +9059,7 @@ void HqlScopeTagger::checkActiveRow(IHqlExpression * expr)
         getECL(expr, exprText);
         elideString(exprText, 20);
         VStringBuffer msg("ROW(%s) - dataset argument is not in scope.  Did you mean dataset[1]?", exprText.str());
-        reportError(msg, SeverityFatal);
+        reportError(CategoryError, msg);
     }
 }
 
@@ -9090,7 +9090,7 @@ void HqlScopeTagger::reportSelectorError(IHqlExpression * selector, IHqlExpressi
             getExprIdentifier(datasetName, selector).str());
     }
 
-    reportError(msg, SeverityFatal);
+    reportError(CategoryError, msg);
 }
 
 
@@ -9108,7 +9108,7 @@ IHqlExpression * HqlScopeTagger::transformSelect(IHqlExpression * expr)
             case no_right:
                 StringBuffer exprText, datasetName;
                 VStringBuffer msg("%s - %s not in scope, possibly passed into a global/workflow definition", getECL(expr, exprText), getExprIdentifier(datasetName, ds).str());
-                reportError(msg, SeverityFatal);
+                reportError(CategoryError, msg);
                 break;
             }
         }
@@ -9122,7 +9122,7 @@ IHqlExpression * HqlScopeTagger::transformSelect(IHqlExpression * expr)
         {
             StringBuffer exprText;
             VStringBuffer msg("dictionary %s must be explicitly NORMALIZED", getECL(expr, exprText));
-            reportError(msg, SeverityFatal);
+            reportError(CategoryError, msg);
         }
         else if (expr->isDataset())
         {
@@ -9130,7 +9130,7 @@ IHqlExpression * HqlScopeTagger::transformSelect(IHqlExpression * expr)
             {
                 StringBuffer exprText;
                 VStringBuffer msg("dataset %s may not be supported without using NORMALIZE", getECL(expr, exprText));
-                reportError(msg, SeverityWarning);
+                reportError(CategoryUnexpected, msg);
             }
         }
         else
@@ -9207,7 +9207,7 @@ IHqlExpression * HqlScopeTagger::transformNewDataset(IHqlExpression * expr, bool
             {
                 StringBuffer exprText;
                 VStringBuffer msg("%s - Need to use active(dataset) to refer to the current row of an active dataset", getECL(expr, exprText));
-                reportError(msg, SeverityFatal);
+                reportError(CategoryError, msg);
             }
         }
         return transformed.getClear();
@@ -9219,7 +9219,7 @@ IHqlExpression * HqlScopeTagger::transformNewDataset(IHqlExpression * expr, bool
         {
             StringBuffer exprText;
             VStringBuffer msg("%s - Need to use active(dataset) to refer to the current row of an active dataset", getECL(expr, exprText));
-            reportError(msg, SeverityFatal);
+            reportError(CategoryError, msg);
         }
 
         return ensureActiveRow(transformed->queryNormalizedSelector());
@@ -9327,7 +9327,7 @@ IHqlExpression * HqlScopeTagger::transformWithin(IHqlExpression * dataset, IHqlE
     {
         StringBuffer exprText;
         VStringBuffer msg("%s - dataset filtered by WITHIN is too complex", getECL(dataset, exprText));
-        reportError(msg, SeverityFatal);
+        reportError(CategoryError, msg);
         return transform(dataset);
     }
 
@@ -9351,7 +9351,7 @@ IHqlExpression * HqlScopeTagger::transformRelated(IHqlExpression * expr)
     {
         StringBuffer exprText;
         VStringBuffer msg("dataset \"%s\" used in WITHIN is not in scope", getECL(scope, exprText));
-        reportError(msg, SeverityFatal);
+        reportError(CategoryError, msg);
     }
 
     //Check the ds is a table
@@ -9360,7 +9360,7 @@ IHqlExpression * HqlScopeTagger::transformRelated(IHqlExpression * expr)
     {
         StringBuffer exprText;
         VStringBuffer msg("dataset \"%s\" used as parameter to WITHIN is too complex", getECL(expr, exprText));
-        reportError(msg, SeverityFatal);
+        reportError(CategoryError, msg);
     }
 
     return transformWithin(ds, scope->queryNormalizedSelector());
@@ -9436,7 +9436,7 @@ IHqlExpression * HqlScopeTagger::createTransformed(IHqlExpression * expr)
             {
                 StringBuffer exprText;
                 VStringBuffer msg("dataset %s mistakenly interpreted as a datarow, possibly due to missing dataset() in parameter type", getECL(ds, exprText));
-                reportError(msg, SeverityFatal);
+                reportError(CategoryError, msg);
             }
             return transformAmbiguousChildren(expr);
         }
@@ -9464,7 +9464,7 @@ IHqlExpression * HqlScopeTagger::createTransformed(IHqlExpression * expr)
             {
                 StringBuffer exprText;
                 VStringBuffer msg("dataset expression (%s) assigned to field '%s' with type row", getECL(rhs, exprText), lhs->queryChild(1)->queryName()->str());
-                reportError(msg.str(), SeverityFatal);
+                reportError(CategoryError, msg.str());
             }
             if (rhs == newRhs)
                 return LINK(expr);
@@ -9480,7 +9480,7 @@ IHqlExpression * HqlScopeTagger::createTransformed(IHqlExpression * expr)
         {
             OwnedHqlExpr transformed = Parent::createTransformed(expr);
             if (transformed->queryChild(0)->isDataset())
-                reportError("PROJECT() row argument resolved to a dataset.  Missing DATASET() from parameter type?", SeverityFatal);
+                reportError(CategoryError, "PROJECT() row argument resolved to a dataset.  Missing DATASET() from parameter type?");
             return transformed.getClear();
         }
     case no_merge:
@@ -9504,7 +9504,7 @@ IHqlExpression * HqlScopeTagger::createTransformed(IHqlExpression * expr)
                 {
                     if (sorts.item(i).isAttribute())
                     {
-                        reportError(HQLWRN_MergeBadSortOrder_Text, SeverityWarning);
+                        reportError(CategorySyntax, HQLWRN_MergeBadSortOrder_Text);
                         sorts.remove(i);
                     }
                 }
@@ -9518,14 +9518,15 @@ IHqlExpression * HqlScopeTagger::createTransformed(IHqlExpression * expr)
 }
 
 
-void HqlScopeTagger::reportError(const char * msg, ErrorSeverity severity)
+void HqlScopeTagger::reportError(WarnErrorCategory category, const char * msg)
 {
     IHqlExpression * location = errorMapper.queryActiveSymbol();
     //Make this an error when we are confident...
     int startLine= location ? location->getStartLine() : 0;
     int startColumn = location ? location->getStartColumn() : 0;
     ISourcePath * sourcePath = location ? location->querySourcePath() : NULL;
-    Owned<IECLError> err = createECLError(severity, ERR_ASSERT_WRONGSCOPING, msg, sourcePath->str(), startLine, startColumn, 0);
+    ErrorSeverity severity = queryDefaultSeverity(category);
+    Owned<IECLError> err = createECLError(category, severity, ERR_ASSERT_WRONGSCOPING, msg, sourcePath->str(), startLine, startColumn, 0);
     errors.report(err);        // will throw immediately if it is an error.
 }
 

ecl/hqlcpp/hqlttcpp.ipp

@@ -1045,7 +1045,7 @@ protected:
     IHqlExpression * transformWithin(IHqlExpression * dataset, IHqlExpression * scope);
 
     bool isValidNormalizeSelector(IHqlExpression * expr);
-    void reportError(const char * msg, ErrorSeverity severity);
+    void reportError(WarnErrorCategory category, const char * msg);
     void reportSelectorError(IHqlExpression * selector, IHqlExpression * expr);
 
 protected: