sassc 2.0.0 → 2.4.0

data/ext/libsass/src/error_handling.cpp

@@ -1,4 +1,7 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include "ast.hpp"
 #include "prelexer.hpp"
 #include "backtrace.hpp"
@@ -10,196 +13,191 @@ namespace Sass {
 
   namespace Exception {
 
-    Base::Base(ParserState pstate, std::string msg, Backtraces traces)
-    : std::runtime_error(msg), msg(msg),
+    Base::Base(SourceSpan pstate, sass::string msg, Backtraces traces)
+    : std::runtime_error(msg.c_str()), msg(msg),
       prefix("Error"), pstate(pstate), traces(traces)
     { }
 
-    InvalidSass::InvalidSass(ParserState pstate, Backtraces traces, std::string msg)
+    InvalidSass::InvalidSass(SourceSpan pstate, Backtraces traces, sass::string msg)
     : Base(pstate, msg, traces)
     { }
 
 
-    InvalidParent::InvalidParent(Selector_Ptr parent, Backtraces traces, Selector_Ptr selector)
+    InvalidParent::InvalidParent(Selector* parent, Backtraces traces, Selector* selector)
     : Base(selector->pstate(), def_msg, traces), parent(parent), selector(selector)
     {
-      msg = "Invalid parent selector for \"";
-      msg += selector->to_string(Sass_Inspect_Options());
-      msg += "\": \"";
-      msg += parent->to_string(Sass_Inspect_Options());
-      msg += "\"";
+      msg = "Invalid parent selector for "
+        "\"" + selector->to_string(Sass_Inspect_Options()) + "\": "
+        "\"" + parent->to_string(Sass_Inspect_Options()) + "\"";
     }
 
-    InvalidVarKwdType::InvalidVarKwdType(ParserState pstate, Backtraces traces, std::string name, const Argument_Ptr arg)
+    InvalidVarKwdType::InvalidVarKwdType(SourceSpan pstate, Backtraces traces, sass::string name, const Argument* arg)
     : Base(pstate, def_msg, traces), name(name), arg(arg)
     {
-      msg = "Variable keyword argument map must have string keys.\n";
-      msg += name + " is not a string in " + arg->to_string() + ".";
+      msg = "Variable keyword argument map must have string keys.\n" +
+        name + " is not a string in " + arg->to_string() + ".";
     }
 
-    InvalidArgumentType::InvalidArgumentType(ParserState pstate, Backtraces traces, std::string fn, std::string arg, std::string type, const Value_Ptr value)
+    InvalidArgumentType::InvalidArgumentType(SourceSpan pstate, Backtraces traces, sass::string fn, sass::string arg, sass::string type, const Value* value)
     : Base(pstate, def_msg, traces), fn(fn), arg(arg), type(type), value(value)
     {
-      msg  = arg + ": \"";
+      msg = arg + ": \"";
       if (value) msg += value->to_string(Sass_Inspect_Options());
-      msg += "\" is not a " + type;
-      msg += " for `" + fn + "'";
+      msg += "\" is not a " + type + " for `" + fn + "'";
     }
 
-    MissingArgument::MissingArgument(ParserState pstate, Backtraces traces, std::string fn, std::string arg, std::string fntype)
+    MissingArgument::MissingArgument(SourceSpan pstate, Backtraces traces, sass::string fn, sass::string arg, sass::string fntype)
     : Base(pstate, def_msg, traces), fn(fn), arg(arg), fntype(fntype)
     {
-      msg  = fntype + " " + fn;
-      msg += " is missing argument ";
-      msg += arg + ".";
+      msg = fntype + " " + fn + " is missing argument " + arg + ".";
     }
 
-    InvalidSyntax::InvalidSyntax(ParserState pstate, Backtraces traces, std::string msg)
+    InvalidSyntax::InvalidSyntax(SourceSpan pstate, Backtraces traces, sass::string msg)
     : Base(pstate, msg, traces)
     { }
 
-    NestingLimitError::NestingLimitError(ParserState pstate, Backtraces traces, std::string msg)
+    NestingLimitError::NestingLimitError(SourceSpan pstate, Backtraces traces, sass::string msg)
     : Base(pstate, msg, traces)
     { }
 
     DuplicateKeyError::DuplicateKeyError(Backtraces traces, const Map& dup, const Expression& org)
     : Base(org.pstate(), def_msg, traces), dup(dup), org(org)
     {
-      msg  = "Duplicate key ";
-      msg += dup.get_duplicate_key()->inspect();
-      msg += " in map (";
-      msg += org.inspect();
-      msg += ").";
+      msg = "Duplicate key " + dup.get_duplicate_key()->inspect() + " in map (" + org.inspect() + ").";
     }
 
-    TypeMismatch::TypeMismatch(Backtraces traces, const Expression& var, const std::string type)
+    TypeMismatch::TypeMismatch(Backtraces traces, const Expression& var, const sass::string type)
     : Base(var.pstate(), def_msg, traces), var(var), type(type)
     {
-      msg  = var.to_string();
-      msg += " is not an ";
-      msg += type;
-      msg += ".";
+      msg = var.to_string() + " is not an " + type + ".";
     }
 
     InvalidValue::InvalidValue(Backtraces traces, const Expression& val)
     : Base(val.pstate(), def_msg, traces), val(val)
     {
-      msg  = val.to_string();
-      msg += " isn't a valid CSS value.";
+      msg = val.to_string() + " isn't a valid CSS value.";
     }
 
     StackError::StackError(Backtraces traces, const AST_Node& node)
     : Base(node.pstate(), def_msg, traces), node(node)
     {
-      msg  = "stack level too deep";
+      msg = "stack level too deep";
     }
 
     IncompatibleUnits::IncompatibleUnits(const Units& lhs, const Units& rhs)
     {
-      msg  = "Incompatible units: '";
-      msg += rhs.unit();
-      msg += "' and '";
-      msg += lhs.unit();
-      msg += "'.";
+      msg = "Incompatible units: '" + rhs.unit() + "' and '" + lhs.unit() + "'.";
     }
 
     IncompatibleUnits::IncompatibleUnits(const UnitType lhs, const UnitType rhs)
     {
-      msg  = "Incompatible units: '";
-      msg += unit_to_string(rhs);
-      msg += "' and '";
-      msg += unit_to_string(lhs);
-      msg += "'.";
+      msg = sass::string("Incompatible units: '") + unit_to_string(rhs) + "' and '" + unit_to_string(lhs) + "'.";
     }
 
-    AlphaChannelsNotEqual::AlphaChannelsNotEqual(Expression_Ptr_Const lhs, Expression_Ptr_Const rhs, enum Sass_OP op)
+    AlphaChannelsNotEqual::AlphaChannelsNotEqual(const Expression* lhs, const Expression* rhs, enum Sass_OP op)
     : OperationError(), lhs(lhs), rhs(rhs), op(op)
     {
-      msg  = "Alpha channels must be equal: ";
-      msg += lhs->to_string({ NESTED, 5 });
-      msg += " " + sass_op_to_name(op) + " ";
-      msg += rhs->to_string({ NESTED, 5 });
-      msg += ".";
+      msg = "Alpha channels must be equal: " +
+        lhs->to_string({ NESTED, 5 }) +
+        " " + sass_op_to_name(op) + " " +
+        rhs->to_string({ NESTED, 5 }) + ".";
     }
 
     ZeroDivisionError::ZeroDivisionError(const Expression& lhs, const Expression& rhs)
     : OperationError(), lhs(lhs), rhs(rhs)
     {
-      msg  = "divided by 0";
+      msg = "divided by 0";
     }
 
-    UndefinedOperation::UndefinedOperation(Expression_Ptr_Const lhs, Expression_Ptr_Const rhs, enum Sass_OP op)
+    UndefinedOperation::UndefinedOperation(const Expression* lhs, const Expression* rhs, enum Sass_OP op)
     : OperationError(), lhs(lhs), rhs(rhs), op(op)
     {
-      msg  = def_op_msg + ": \"";
-      msg += lhs->to_string({ NESTED, 5 });
-      msg += " " + sass_op_to_name(op) + " ";
-      msg += rhs->to_string({ TO_SASS, 5 });
-      msg += "\".";
+      msg = def_op_msg + ": \"" +
+        lhs->to_string({ NESTED, 5 }) +
+        " " + sass_op_to_name(op) + " " +
+        rhs->to_string({ TO_SASS, 5 }) +
+        "\".";
     }
 
-    InvalidNullOperation::InvalidNullOperation(Expression_Ptr_Const lhs, Expression_Ptr_Const rhs, enum Sass_OP op)
+    InvalidNullOperation::InvalidNullOperation(const Expression* lhs, const Expression* rhs, enum Sass_OP op)
     : UndefinedOperation(lhs, rhs, op)
     {
-      msg  = def_op_null_msg + ": \"";
-      msg += lhs->inspect();
-      msg += " " + sass_op_to_name(op) + " ";
-      msg += rhs->inspect();
-      msg += "\".";
+      msg = def_op_null_msg + ": \"" + lhs->inspect() + " " + sass_op_to_name(op) + " " + rhs->inspect() + "\".";
     }
 
-    SassValueError::SassValueError(Backtraces traces, ParserState pstate, OperationError& err)
+    SassValueError::SassValueError(Backtraces traces, SourceSpan pstate, OperationError& err)
     : Base(pstate, err.what(), traces)
     {
       msg = err.what();
       prefix = err.errtype();
     }
 
+    TopLevelParent::TopLevelParent(Backtraces traces, SourceSpan pstate)
+      : Base(pstate, "Top-level selectors may not contain the parent selector \"&\".", traces)
+    {
+
+    }
+
+    UnsatisfiedExtend::UnsatisfiedExtend(Backtraces traces, Extension extension)
+      : Base(extension.target->pstate(), "The target selector was not found.\n"
+        "Use \"@extend " + extension.target->to_string() + " !optional\" to avoid this error.", traces)
+    {
+
+    }
+
+    ExtendAcrossMedia::ExtendAcrossMedia(Backtraces traces, Extension extension)
+      : Base(extension.target->pstate(), "You may not @extend selectors across media queries.\n"
+        "Use \"@extend " + extension.target->to_string() + " !optional\" to avoid this error.", traces)
+    {
+
+    }
+    
+
   }
 
 
-  void warn(std::string msg, ParserState pstate)
+  void warn(sass::string msg, SourceSpan pstate)
   {
     std::cerr << "Warning: " << msg << std::endl;
   }
 
-  void warning(std::string msg, ParserState pstate)
+  void warning(sass::string msg, SourceSpan pstate)
   {
-    std::string cwd(Sass::File::get_cwd());
-    std::string abs_path(Sass::File::rel2abs(pstate.path, cwd, cwd));
-    std::string rel_path(Sass::File::abs2rel(pstate.path, cwd, cwd));
-    std::string output_path(Sass::File::path_for_console(rel_path, abs_path, pstate.path));
+    sass::string cwd(Sass::File::get_cwd());
+    sass::string abs_path(Sass::File::rel2abs(pstate.getPath(), cwd, cwd));
+    sass::string rel_path(Sass::File::abs2rel(pstate.getPath(), cwd, cwd));
+    sass::string output_path(Sass::File::path_for_console(rel_path, abs_path, pstate.getPath()));
 
-    std::cerr << "WARNING on line " << pstate.line+1 << ", column " << pstate.column+1 << " of " << output_path << ":" << std::endl;
+    std::cerr << "WARNING on line " << pstate.getLine() << ", column " << pstate.getColumn() << " of " << output_path << ":" << std::endl;
     std::cerr << msg << std::endl << std::endl;
   }
 
-  void warn(std::string msg, ParserState pstate, Backtrace* bt)
+  void warn(sass::string msg, SourceSpan pstate, Backtrace* bt)
   {
     warn(msg, pstate);
   }
 
-  void deprecated_function(std::string msg, ParserState pstate)
+  void deprecated_function(sass::string msg, SourceSpan pstate)
   {
-    std::string cwd(Sass::File::get_cwd());
-    std::string abs_path(Sass::File::rel2abs(pstate.path, cwd, cwd));
-    std::string rel_path(Sass::File::abs2rel(pstate.path, cwd, cwd));
-    std::string output_path(Sass::File::path_for_console(rel_path, abs_path, pstate.path));
+    sass::string cwd(Sass::File::get_cwd());
+    sass::string abs_path(Sass::File::rel2abs(pstate.getPath(), cwd, cwd));
+    sass::string rel_path(Sass::File::abs2rel(pstate.getPath(), cwd, cwd));
+    sass::string output_path(Sass::File::path_for_console(rel_path, abs_path, pstate.getPath()));
 
     std::cerr << "DEPRECATION WARNING: " << msg << std::endl;
     std::cerr << "will be an error in future versions of Sass." << std::endl;
-    std::cerr << "        on line " << pstate.line+1 << " of " << output_path << std::endl;
+    std::cerr << "        on line " << pstate.getLine() << " of " << output_path << std::endl;
   }
 
-  void deprecated(std::string msg, std::string msg2, bool with_column, ParserState pstate)
+  void deprecated(sass::string msg, sass::string msg2, bool with_column, SourceSpan pstate)
   {
-    std::string cwd(Sass::File::get_cwd());
-    std::string abs_path(Sass::File::rel2abs(pstate.path, cwd, cwd));
-    std::string rel_path(Sass::File::abs2rel(pstate.path, cwd, cwd));
-    std::string output_path(Sass::File::path_for_console(rel_path, pstate.path, pstate.path));
+    sass::string cwd(Sass::File::get_cwd());
+    sass::string abs_path(Sass::File::rel2abs(pstate.getPath(), cwd, cwd));
+    sass::string rel_path(Sass::File::abs2rel(pstate.getPath(), cwd, cwd));
+    sass::string output_path(Sass::File::path_for_console(rel_path, pstate.getPath(), pstate.getPath()));
 
-    std::cerr << "DEPRECATION WARNING on line " << pstate.line + 1;
-    if (with_column) std::cerr << ", column " << pstate.column + pstate.offset.column + 1;
+    std::cerr << "DEPRECATION WARNING on line " << pstate.getLine();
+    // if (with_column) std::cerr << ", column " << pstate.column + pstate.offset.column + 1;
     if (output_path.length()) std::cerr << " of " << output_path;
     std::cerr << ":" << std::endl;
     std::cerr << msg << std::endl;
@@ -207,26 +205,26 @@ namespace Sass {
     std::cerr << std::endl;
   }
 
-  void deprecated_bind(std::string msg, ParserState pstate)
+  void deprecated_bind(sass::string msg, SourceSpan pstate)
   {
-    std::string cwd(Sass::File::get_cwd());
-    std::string abs_path(Sass::File::rel2abs(pstate.path, cwd, cwd));
-    std::string rel_path(Sass::File::abs2rel(pstate.path, cwd, cwd));
-    std::string output_path(Sass::File::path_for_console(rel_path, abs_path, pstate.path));
+    sass::string cwd(Sass::File::get_cwd());
+    sass::string abs_path(Sass::File::rel2abs(pstate.getPath(), cwd, cwd));
+    sass::string rel_path(Sass::File::abs2rel(pstate.getPath(), cwd, cwd));
+    sass::string output_path(Sass::File::path_for_console(rel_path, abs_path, pstate.getPath()));
 
     std::cerr << "WARNING: " << msg << std::endl;
-    std::cerr << "        on line " << pstate.line+1 << " of " << output_path << std::endl;
+    std::cerr << "        on line " << pstate.getLine() << " of " << output_path << std::endl;
     std::cerr << "This will be an error in future versions of Sass." << std::endl;
   }
 
   // should be replaced with error with backtraces
-  void coreError(std::string msg, ParserState pstate)
+  void coreError(sass::string msg, SourceSpan pstate)
   {
     Backtraces traces;
     throw Exception::InvalidSyntax(pstate, traces, msg);
   }
 
-  void error(std::string msg, ParserState pstate, Backtraces& traces)
+  void error(sass::string msg, SourceSpan pstate, Backtraces& traces)
   {
     traces.push_back(Backtrace(pstate));
     throw Exception::InvalidSyntax(pstate, traces, msg);

data/ext/libsass/src/error_handling.hpp

@@ -1,9 +1,14 @@
 #ifndef SASS_ERROR_HANDLING_H
 #define SASS_ERROR_HANDLING_H
 
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
 #include <string>
 #include <sstream>
 #include <stdexcept>
+#include "units.hpp"
 #include "position.hpp"
 #include "backtrace.hpp"
 #include "ast_fwd_decl.hpp"
@@ -15,20 +20,20 @@ namespace Sass {
 
   namespace Exception {
 
-    const std::string def_msg = "Invalid sass detected";
-    const std::string def_op_msg = "Undefined operation";
-    const std::string def_op_null_msg = "Invalid null operation";
-    const std::string def_nesting_limit = "Code too deeply neested";
+    const sass::string def_msg = "Invalid sass detected";
+    const sass::string def_op_msg = "Undefined operation";
+    const sass::string def_op_null_msg = "Invalid null operation";
+    const sass::string def_nesting_limit = "Code too deeply nested";
 
     class Base : public std::runtime_error {
       protected:
-        std::string msg;
-        std::string prefix;
+        sass::string msg;
+        sass::string prefix;
       public:
-        ParserState pstate;
+        SourceSpan pstate;
         Backtraces traces;
       public:
-        Base(ParserState pstate, std::string msg, Backtraces traces);
+        Base(SourceSpan pstate, sass::string msg, Backtraces traces);
         virtual const char* errtype() const { return prefix.c_str(); }
         virtual const char* what() const throw() { return msg.c_str(); }
         virtual ~Base() throw() {};
@@ -36,58 +41,58 @@ namespace Sass {
 
     class InvalidSass : public Base {
       public:
-        InvalidSass(ParserState pstate, Backtraces traces, std::string msg);
+        InvalidSass(SourceSpan pstate, Backtraces traces, sass::string msg);
         virtual ~InvalidSass() throw() {};
     };
 
     class InvalidParent : public Base {
       protected:
-        Selector_Ptr parent;
-        Selector_Ptr selector;
+        Selector* parent;
+        Selector* selector;
       public:
-        InvalidParent(Selector_Ptr parent, Backtraces traces, Selector_Ptr selector);
+        InvalidParent(Selector* parent, Backtraces traces, Selector* selector);
         virtual ~InvalidParent() throw() {};
     };
 
     class MissingArgument : public Base {
       protected:
-        std::string fn;
-        std::string arg;
-        std::string fntype;
+        sass::string fn;
+        sass::string arg;
+        sass::string fntype;
       public:
-        MissingArgument(ParserState pstate, Backtraces traces, std::string fn, std::string arg, std::string fntype);
+        MissingArgument(SourceSpan pstate, Backtraces traces, sass::string fn, sass::string arg, sass::string fntype);
         virtual ~MissingArgument() throw() {};
     };
 
     class InvalidArgumentType : public Base {
       protected:
-        std::string fn;
-        std::string arg;
-        std::string type;
-        const Value_Ptr value;
+        sass::string fn;
+        sass::string arg;
+        sass::string type;
+        const Value* value;
       public:
-        InvalidArgumentType(ParserState pstate, Backtraces traces, std::string fn, std::string arg, std::string type, const Value_Ptr value = 0);
+        InvalidArgumentType(SourceSpan pstate, Backtraces traces, sass::string fn, sass::string arg, sass::string type, const Value* value = 0);
         virtual ~InvalidArgumentType() throw() {};
     };
 
     class InvalidVarKwdType : public Base {
       protected:
-        std::string name;
-        const Argument_Ptr arg;
+        sass::string name;
+        const Argument* arg;
       public:
-        InvalidVarKwdType(ParserState pstate, Backtraces traces, std::string name, const Argument_Ptr arg = 0);
+        InvalidVarKwdType(SourceSpan pstate, Backtraces traces, sass::string name, const Argument* arg = 0);
         virtual ~InvalidVarKwdType() throw() {};
     };
 
     class InvalidSyntax : public Base {
       public:
-        InvalidSyntax(ParserState pstate, Backtraces traces, std::string msg);
+        InvalidSyntax(SourceSpan pstate, Backtraces traces, sass::string msg);
         virtual ~InvalidSyntax() throw() {};
     };
 
     class NestingLimitError : public Base {
       public:
-        NestingLimitError(ParserState pstate, Backtraces traces, std::string msg = def_nesting_limit);
+        NestingLimitError(SourceSpan pstate, Backtraces traces, sass::string msg = def_nesting_limit);
         virtual ~NestingLimitError() throw() {};
     };
 
@@ -104,9 +109,9 @@ namespace Sass {
     class TypeMismatch : public Base {
       protected:
         const Expression& var;
-        const std::string type;
+        const sass::string type;
       public:
-        TypeMismatch(Backtraces traces, const Expression& var, const std::string type);
+        TypeMismatch(Backtraces traces, const Expression& var, const sass::string type);
         virtual const char* errtype() const { return "Error"; }
         virtual ~TypeMismatch() throw() {};
     };
@@ -132,10 +137,10 @@ namespace Sass {
     /* common virtual base class (has no pstate or trace) */
     class OperationError : public std::runtime_error {
       protected:
-        std::string msg;
+        sass::string msg;
       public:
-        OperationError(std::string msg = def_op_msg)
-        : std::runtime_error(msg), msg(msg)
+        OperationError(sass::string msg = def_op_msg)
+        : std::runtime_error(msg.c_str()), msg(msg)
         {};
       public:
         virtual const char* errtype() const { return "Error"; }
@@ -165,51 +170,69 @@ namespace Sass {
 
     class UndefinedOperation : public OperationError {
       protected:
-        Expression_Ptr_Const lhs;
-        Expression_Ptr_Const rhs;
+        const Expression* lhs;
+        const Expression* rhs;
         const Sass_OP op;
       public:
-        UndefinedOperation(Expression_Ptr_Const lhs, Expression_Ptr_Const rhs, enum Sass_OP op);
+        UndefinedOperation(const Expression* lhs, const Expression* rhs, enum Sass_OP op);
         // virtual const char* errtype() const { return "Error"; }
         virtual ~UndefinedOperation() throw() {};
     };
 
     class InvalidNullOperation : public UndefinedOperation {
       public:
-        InvalidNullOperation(Expression_Ptr_Const lhs, Expression_Ptr_Const rhs, enum Sass_OP op);
+        InvalidNullOperation(const Expression* lhs, const Expression* rhs, enum Sass_OP op);
         virtual ~InvalidNullOperation() throw() {};
     };
 
     class AlphaChannelsNotEqual : public OperationError {
       protected:
-        Expression_Ptr_Const lhs;
-        Expression_Ptr_Const rhs;
+        const Expression* lhs;
+        const Expression* rhs;
         const Sass_OP op;
       public:
-        AlphaChannelsNotEqual(Expression_Ptr_Const lhs, Expression_Ptr_Const rhs, enum Sass_OP op);
+        AlphaChannelsNotEqual(const Expression* lhs, const Expression* rhs, enum Sass_OP op);
         // virtual const char* errtype() const { return "Error"; }
         virtual ~AlphaChannelsNotEqual() throw() {};
     };
 
     class SassValueError : public Base {
-      public:
-        SassValueError(Backtraces traces, ParserState pstate, OperationError& err);
-        virtual ~SassValueError() throw() {};
+    public:
+      SassValueError(Backtraces traces, SourceSpan pstate, OperationError& err);
+      virtual ~SassValueError() throw() {};
+    };
+
+    class TopLevelParent : public Base {
+    public:
+      TopLevelParent(Backtraces traces, SourceSpan pstate);
+      virtual ~TopLevelParent() throw() {};
+    };
+
+    class UnsatisfiedExtend : public Base {
+    public:
+      UnsatisfiedExtend(Backtraces traces, Extension extension);
+      virtual ~UnsatisfiedExtend() throw() {};
+    };
+
+    class ExtendAcrossMedia : public Base {
+    public:
+      ExtendAcrossMedia(Backtraces traces, Extension extension);
+      virtual ~ExtendAcrossMedia() throw() {};
     };
 
   }
 
-  void warn(std::string msg, ParserState pstate);
-  void warn(std::string msg, ParserState pstate, Backtrace* bt);
-  void warning(std::string msg, ParserState pstate);
+  void warn(sass::string msg, SourceSpan pstate);
+  void warn(sass::string msg, SourceSpan pstate, Backtrace* bt);
+  void warning(sass::string msg, SourceSpan pstate);
 
-  void deprecated_function(std::string msg, ParserState pstate);
-  void deprecated(std::string msg, std::string msg2, bool with_column, ParserState pstate);
-  void deprecated_bind(std::string msg, ParserState pstate);
-  // void deprecated(std::string msg, ParserState pstate, Backtrace* bt);
+  void deprecated_function(sass::string msg, SourceSpan pstate);
+  void deprecated(sass::string msg, sass::string msg2, bool with_column, SourceSpan pstate);
+  void deprecated_bind(sass::string msg, SourceSpan pstate);
+  // void deprecated(sass::string msg, SourceSpan pstate, Backtrace* bt);
 
-  void coreError(std::string msg, ParserState pstate);
-  void error(std::string msg, ParserState pstate, Backtraces& traces);
+  void coreError(sass::string msg, SourceSpan pstate);
+  void error(sass::string msg, SourceSpan pstate, Backtraces& traces);
 
 }