Load can't be moved to compiler.cpp

mgreter · mgreter · commit 97199666f329 · 2020-12-07T00:00:27.000+01:00
Since meta.load-css is fully dynamic!
Maybe marry compiler and eval even?
diff --git a/src/ast_values.cpp b/src/ast_values.cpp
@@ -697,7 +697,7 @@ namespace Sass {
         return l.value() > r.value();
       }
       // Throw error, unit are incompatible
-      logger.addFinalStackTrace(pstate);//XXX
+      callStackFrame csf(logger, pstate);
       throw Exception::UnitMismatch(
         logger, this, rhs);
     }
@@ -726,7 +726,7 @@ namespace Sass {
         return l.value() >= r.value();
       }
       // Throw error, unit are incompatible
-      logger.addFinalStackTrace(pstate);//XXX
+      callStackFrame csf(logger, pstate);
       throw Exception::UnitMismatch(
         logger, this, rhs);
     }
@@ -755,7 +755,7 @@ namespace Sass {
         return l.value() < r.value();
       }
       // Throw error, unit are incompatible
-      logger.addFinalStackTrace(pstate);//XXX
+      callStackFrame csf(logger, pstate);
       throw Exception::UnitMismatch(
         logger, this, rhs);
     }
diff --git a/src/backtrace.hpp b/src/backtrace.hpp
@@ -51,6 +51,11 @@ namespace Sass {
       return name;
     }
 
+    bool operator==(const StackTrace& other) const {
+      return pstate == other.pstate &&
+        name == other.name && fn == other.fn;
+    }
+
     bool isFn() const override final {
       return fn;
     }
diff --git a/src/compiler.cpp b/src/compiler.cpp
@@ -25,6 +25,8 @@
 #include "fn_colors.hpp"
 #include "fn_selectors.hpp"
 
+#include "preloader.hpp"
+
 #include <cstring>
 #include <csignal>
 #ifdef _MSC_VER
@@ -239,6 +241,9 @@ struct SassValue* fn_##fn(struct SassValue* s_args, Sass_Function_Entry cb, stru
 
     Eval eval(*this, *this, plainCss);
 
+    // Preloader preloader(*this, root);
+    // preloader.process();
+
     CssRootObj compiled = eval.acceptRoot(root); // 50%
     // debug_ast(compiled);
 
diff --git a/src/context.hpp b/src/context.hpp
@@ -52,11 +52,6 @@ namespace Sass {
     // Same order needed for function stack
     std::vector<CallableObj> fnList;
 
-    // Lookup functions by function name
-    // Due to EnvKayMap case insensitive.
-    EnvKeyMap<CallableObj> fnLookup;
-
-
   public:
 
     // sass::vector<WithConfigVar>* withConfig = nullptr;
diff --git a/src/environment.cpp b/src/environment.cpp
@@ -526,24 +526,17 @@ namespace Sass {
     ImportObj loaded = compiler.loadImport(resolved[0]);
     ImportStackFrame iframe(compiler, loaded);
 
-    Root* sheet = nullptr;
     sass::string abspath(loaded->getAbsPath());
     auto cached = compiler.sheets.find(abspath);
     if (cached != compiler.sheets.end()) {
-      sheet = cached->second;
+      return cached->second;
     }
-    else {
-      // Permeable seems to have minor negative impact!?
-      EnvFrame local(compiler, false, true, isImport); // correct
-      sheet = compiler.registerImport(loaded);
-      sheet->idxs = local.idxs;
-      sheet->import = loaded;
-    }
-
-    // rule->module(sheet);
-    // rule->sheet(sheet);
 
-    // wconfig.finalize();
+    // Permeable seems to have minor negative impact!?
+    EnvFrame local(compiler, false, true, isImport); // correct
+    Root* sheet = compiler.registerImport(loaded);
+    sheet->idxs = local.idxs;
+    sheet->import = loaded;
     return sheet;
   }
 
@@ -796,7 +789,6 @@ namespace Sass {
         rule->wasExported(true);
       }
       else if (frame->module->moduse.count(rule->ns())) {
-        compiler.addFinalStackTrace(rule->pstate());//XXX
         throw Exception::ModuleAlreadyKnown(compiler, rule->ns());
       }
       else {
diff --git a/src/fn_colors.cpp b/src/fn_colors.cpp
@@ -1060,8 +1060,7 @@ namespace Sass {
           // Support the proprietary Microsoft alpha() function.
           return getFunctionString(Strings::alpha, pstate, arguments);
         }
-        compiler.addFinalStackTrace(arguments[0]->pstate());//XXX
-        // callStackFrame csf(compiler, arguments[0]->pstate());
+        callStackFrame csf(compiler, arguments[0]->pstate());
         throw Exception::TooManyArguments(compiler, size, 1);
       }
 
diff --git a/src/fn_selectors.cpp b/src/fn_selectors.cpp
@@ -51,7 +51,6 @@ namespace Sass {
         // Iterate over the rest argument list
         for (Value* arg : arguments[0]->iterator()) {
           if (arg->isNull()) {
-            // compiler.addFinalStackTrace(arg->pstate());
             callStackFrame csf(compiler, arg->pstate());
             throw Exception::RuntimeException(compiler, // "$selectors: "
               "null is not a valid selector: it must be a string,\n"
diff --git a/src/logger.cpp b/src/logger.cpp
@@ -596,6 +596,7 @@ namespace Sass {
 
     i_beg = traces.size() - 1;
     i_end = sass::string::npos;
+    const StackTrace* prev = nullptr;
     for (size_t i = i_beg; i != i_end; i--) {
 
       const StackTrace& trace = traces[i];
@@ -607,8 +608,10 @@ namespace Sass {
       // if (trace.caller.substr(0, 6) == ", in f") continue;
 
       if (amount == sass::string::npos || amount > 0) {
+        if (prev && *prev == trace) continue;
         printSourceSpan(trace.pstate, os, style);
         if (amount > 0) --amount;
+        prev = &trace;
       }
 
       if (showPos) {
diff --git a/src/logger.hpp b/src/logger.hpp
@@ -34,24 +34,6 @@ namespace Sass {
     // Flag for unicode and/or color
     enum SassLoggerStyle style;
 
-    // Append the pstate if not already there
-    // Only call this right before throwing errors
-    // DONT USE, CAN LEAD TO SEGFAULTS IF THE ERROR
-    // WE THROW RIGHT AFTER IS CAUGHT AND BACKTRACKED
-    void addFinalStackTrace(const SourceSpan& pstate)
-    {
-      if (callStack.empty()) {
-        callStack.push_back(pstate);
-      }
-      else {
-        BackTrace& trace(callStack.back());
-        if (!(trace.pstate == pstate)) {
-          callStack.push_back(pstate);
-        }
-      }
-    }
-    // EO addFinalStackTrace
-
   private:
 
     // Split the line to three parts for error reporting.
diff --git a/src/preloader.cpp b/src/preloader.cpp
@@ -14,6 +14,7 @@ namespace Sass {
   Preloader::Preloader(Eval& eval, Root* root) :
     eval(eval),
     root(root),
+    compiler(eval.compiler),
     chroot77(eval.chroot77),
     wconfig(eval.wconfig),
     idxs(root->idxs)
@@ -32,41 +33,41 @@ namespace Sass {
     if (sheet && !sheet->empty()) {
       LOCAL_PTR(Root, chroot77, sheet);
       LOCAL_PTR(EnvRefs, idxs, sheet->idxs);
-      ImportStackFrame isf(eval.compiler, sheet->import);
-      eval.compiler.varRoot.stack.push_back(sheet->idxs);
+      ImportStackFrame isf(compiler, sheet->import);
+      compiler.varRoot.stack.push_back(sheet->idxs);
       for (auto& it : sheet->elements()) it->accept(this);
-      eval.compiler.varRoot.stack.pop_back();
+      compiler.varRoot.stack.pop_back();
     }
   }
 
   void Preloader::visitParentStatement(ParentStatement* rule)
   {
     if (rule->empty()) return;
     LOCAL_PTR(EnvRefs, idxs, rule->idxs);
-    eval.compiler.varRoot.stack.push_back(rule->idxs);
+    compiler.varRoot.stack.push_back(rule->idxs);
     for (auto& it : rule->elements()) it->accept(this);
-    eval.compiler.varRoot.stack.pop_back();
+    compiler.varRoot.stack.pop_back();
   }
 
   void Preloader::visitUseRule(UseRule* rule)
   {
-    callStackFrame frame(eval.compiler, {
+    callStackFrame frame(compiler, {
       rule->pstate(), Strings::useRule });
     acceptRoot(eval.loadModRule(rule));
     eval.exposeUseRule(rule);
   }
 
   void Preloader::visitForwardRule(ForwardRule* rule)
   {
-    callStackFrame frame(eval.compiler, {
+    callStackFrame frame(compiler, {
       rule->pstate(), Strings::forwardRule });
     acceptRoot(eval.loadModRule(rule));
     eval.exposeFwdRule(rule);
   }
 
   void Preloader::visitIncludeImport(IncludeImport* rule)
   {
-    callStackFrame frame(eval.compiler, {
+    callStackFrame frame(compiler, {
       rule->pstate(), Strings::importRule });
     acceptRoot(eval.resolveIncludeImport(rule));
     eval.exposeImpRule(rule);
@@ -81,18 +82,18 @@ namespace Sass {
   {
     // const EnvKey& fname(rule->name());
     LOCAL_PTR(EnvRefs, idxs, rule->idxs);
-    eval.compiler.varRoot.stack.push_back(rule->idxs);
+    compiler.varRoot.stack.push_back(rule->idxs);
     for (auto& it : rule->elements()) it->accept(this);
-    eval.compiler.varRoot.stack.pop_back();
+    compiler.varRoot.stack.pop_back();
   }
 
   void Preloader::visitMixinRule(MixinRule* rule)
   {
     // const EnvKey& mname(rule->name());
     LOCAL_PTR(EnvRefs, idxs, rule->idxs);
-    eval.compiler.varRoot.stack.push_back(rule->idxs);
+    compiler.varRoot.stack.push_back(rule->idxs);
     for (auto& it : rule->elements()) it->accept(this);
-    eval.compiler.varRoot.stack.pop_back();
+    compiler.varRoot.stack.pop_back();
   }
 
   void Preloader::visitImportRule(ImportRule* rule)
@@ -153,9 +154,9 @@ namespace Sass {
   {
     if (ContentBlock* content = rule->content()) {
       LOCAL_PTR(EnvRefs, idxs, content->idxs);
-      eval.compiler.varRoot.stack.push_back(content->idxs);
+      compiler.varRoot.stack.push_back(content->idxs);
       for (auto& it : content->elements()) it->accept(this);
-      eval.compiler.varRoot.stack.pop_back();
+      compiler.varRoot.stack.pop_back();
     }
   }
 
@@ -175,18 +176,18 @@ namespace Sass {
     for (size_t i = 0; i < vars.size(); i += 1) {
       idxs->varIdxs.insert({ vars[i], (uint32_t)i });
     }
-    eval.compiler.varRoot.stack.push_back(rule->idxs);
+    compiler.varRoot.stack.push_back(rule->idxs);
     for (auto& it : rule->elements()) it->accept(this);
-    eval.compiler.varRoot.stack.pop_back();
+    compiler.varRoot.stack.pop_back();
   }
 
   void Preloader::visitForRule(ForRule* rule)
   {
     LOCAL_PTR(EnvRefs, idxs, rule->idxs);
     idxs->varIdxs.insert({ rule->varname(), 0 });
-    eval.compiler.varRoot.stack.push_back(rule->idxs);
+    compiler.varRoot.stack.push_back(rule->idxs);
     for (auto& it : rule->elements()) it->accept(this);
-    eval.compiler.varRoot.stack.pop_back();
+    compiler.varRoot.stack.pop_back();
   }
 
   void Preloader::visitReturnRule(ReturnRule* rule)
diff --git a/src/preloader.hpp b/src/preloader.hpp
@@ -26,6 +26,7 @@ namespace Sass {
 
     Eval& eval;
     Root* root;
+    Compiler& compiler;
 
     // Alias into context
     Root*& chroot77;

Original file line number	Diff line number	Diff line change
`@@ -697,7 +697,7 @@ namespace Sass {`
`697`	`697`	`return l.value() > r.value();`
`698`	`698`	`}`
`699`	`699`	`// Throw error, unit are incompatible`
`700`		`- logger.addFinalStackTrace(pstate);//XXX`
	`700`	`+ callStackFrame csf(logger, pstate);`
`701`	`701`	`throw Exception::UnitMismatch(`
`702`	`702`	`logger, this, rhs);`
`703`	`703`	`}`
`@@ -726,7 +726,7 @@ namespace Sass {`
`726`	`726`	`return l.value() >= r.value();`
`727`	`727`	`}`
`728`	`728`	`// Throw error, unit are incompatible`
`729`		`- logger.addFinalStackTrace(pstate);//XXX`
	`729`	`+ callStackFrame csf(logger, pstate);`
`730`	`730`	`throw Exception::UnitMismatch(`
`731`	`731`	`logger, this, rhs);`
`732`	`732`	`}`
`@@ -755,7 +755,7 @@ namespace Sass {`
`755`	`755`	`return l.value() < r.value();`
`756`	`756`	`}`
`757`	`757`	`// Throw error, unit are incompatible`
`758`		`- logger.addFinalStackTrace(pstate);//XXX`
	`758`	`+ callStackFrame csf(logger, pstate);`
`759`	`759`	`throw Exception::UnitMismatch(`
`760`	`760`	`logger, this, rhs);`
`761`	`761`	`}`
Original file line number	Diff line number	Diff line change
`@@ -51,6 +51,11 @@ namespace Sass {`
`51`	`51`	`return name;`
`52`	`52`	`}`
`53`	`53`
	`54`	`+ bool operator==(const StackTrace& other) const {`
	`55`	`+ return pstate == other.pstate &&`
	`56`	`+ name == other.name && fn == other.fn;`
	`57`	`+ }`
	`58`	`+`
`54`	`59`	`bool isFn() const override final {`
`55`	`60`	`return fn;`
`56`	`61`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1060,8 +1060,7 @@ namespace Sass {`
`1060`	`1060`	`// Support the proprietary Microsoft alpha() function.`
`1061`	`1061`	`return getFunctionString(Strings::alpha, pstate, arguments);`
`1062`	`1062`	`}`
`1063`		`- compiler.addFinalStackTrace(arguments[0]->pstate());//XXX`
`1064`		`- // callStackFrame csf(compiler, arguments[0]->pstate());`
	`1063`	`+ callStackFrame csf(compiler, arguments[0]->pstate());`
`1065`	`1064`	`throw Exception::TooManyArguments(compiler, size, 1);`
`1066`	`1065`	`}`
`1067`	`1066`
Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,7 @@ namespace Sass {`
`14`	`14`	`Preloader::Preloader(Eval& eval, Root* root) :`
`15`	`15`	`eval(eval),`
`16`	`16`	`root(root),`
	`17`	`+ compiler(eval.compiler),`
`17`	`18`	`chroot77(eval.chroot77),`
`18`	`19`	`wconfig(eval.wconfig),`
`19`	`20`	`idxs(root->idxs)`
`@@ -32,41 +33,41 @@ namespace Sass {`
`32`	`33`	`if (sheet && !sheet->empty()) {`
`33`	`34`	`LOCAL_PTR(Root, chroot77, sheet);`
`34`	`35`	`LOCAL_PTR(EnvRefs, idxs, sheet->idxs);`
`35`		`- ImportStackFrame isf(eval.compiler, sheet->import);`
`36`		`- eval.compiler.varRoot.stack.push_back(sheet->idxs);`
	`36`	`+ ImportStackFrame isf(compiler, sheet->import);`
	`37`	`+ compiler.varRoot.stack.push_back(sheet->idxs);`
`37`	`38`	`for (auto& it : sheet->elements()) it->accept(this);`
`38`		`- eval.compiler.varRoot.stack.pop_back();`
	`39`	`+ compiler.varRoot.stack.pop_back();`
`39`	`40`	`}`
`40`	`41`	`}`
`41`	`42`
`42`	`43`	`void Preloader::visitParentStatement(ParentStatement* rule)`
`43`	`44`	`{`
`44`	`45`	`if (rule->empty()) return;`
`45`	`46`	`LOCAL_PTR(EnvRefs, idxs, rule->idxs);`
`46`		`- eval.compiler.varRoot.stack.push_back(rule->idxs);`
	`47`	`+ compiler.varRoot.stack.push_back(rule->idxs);`
`47`	`48`	`for (auto& it : rule->elements()) it->accept(this);`
`48`		`- eval.compiler.varRoot.stack.pop_back();`
	`49`	`+ compiler.varRoot.stack.pop_back();`
`49`	`50`	`}`
`50`	`51`
`51`	`52`	`void Preloader::visitUseRule(UseRule* rule)`
`52`	`53`	`{`
`53`		`- callStackFrame frame(eval.compiler, {`
	`54`	`+ callStackFrame frame(compiler, {`
`54`	`55`	`rule->pstate(), Strings::useRule });`
`55`	`56`	`acceptRoot(eval.loadModRule(rule));`
`56`	`57`	`eval.exposeUseRule(rule);`
`57`	`58`	`}`
`58`	`59`
`59`	`60`	`void Preloader::visitForwardRule(ForwardRule* rule)`
`60`	`61`	`{`
`61`		`- callStackFrame frame(eval.compiler, {`
	`62`	`+ callStackFrame frame(compiler, {`
`62`	`63`	`rule->pstate(), Strings::forwardRule });`
`63`	`64`	`acceptRoot(eval.loadModRule(rule));`
`64`	`65`	`eval.exposeFwdRule(rule);`
`65`	`66`	`}`
`66`	`67`
`67`	`68`	`void Preloader::visitIncludeImport(IncludeImport* rule)`
`68`	`69`	`{`
`69`		`- callStackFrame frame(eval.compiler, {`
	`70`	`+ callStackFrame frame(compiler, {`
`70`	`71`	`rule->pstate(), Strings::importRule });`
`71`	`72`	`acceptRoot(eval.resolveIncludeImport(rule));`
`72`	`73`	`eval.exposeImpRule(rule);`
`@@ -81,18 +82,18 @@ namespace Sass {`
`81`	`82`	`{`
`82`	`83`	`// const EnvKey& fname(rule->name());`
`83`	`84`	`LOCAL_PTR(EnvRefs, idxs, rule->idxs);`
`84`		`- eval.compiler.varRoot.stack.push_back(rule->idxs);`
	`85`	`+ compiler.varRoot.stack.push_back(rule->idxs);`
`85`	`86`	`for (auto& it : rule->elements()) it->accept(this);`
`86`		`- eval.compiler.varRoot.stack.pop_back();`
	`87`	`+ compiler.varRoot.stack.pop_back();`
`87`	`88`	`}`
`88`	`89`
`89`	`90`	`void Preloader::visitMixinRule(MixinRule* rule)`
`90`	`91`	`{`
`91`	`92`	`// const EnvKey& mname(rule->name());`
`92`	`93`	`LOCAL_PTR(EnvRefs, idxs, rule->idxs);`
`93`		`- eval.compiler.varRoot.stack.push_back(rule->idxs);`
	`94`	`+ compiler.varRoot.stack.push_back(rule->idxs);`
`94`	`95`	`for (auto& it : rule->elements()) it->accept(this);`
`95`		`- eval.compiler.varRoot.stack.pop_back();`
	`96`	`+ compiler.varRoot.stack.pop_back();`
`96`	`97`	`}`
`97`	`98`
`98`	`99`	`void Preloader::visitImportRule(ImportRule* rule)`
`@@ -153,9 +154,9 @@ namespace Sass {`
`153`	`154`	`{`
`154`	`155`	`if (ContentBlock* content = rule->content()) {`
`155`	`156`	`LOCAL_PTR(EnvRefs, idxs, content->idxs);`
`156`		`- eval.compiler.varRoot.stack.push_back(content->idxs);`
	`157`	`+ compiler.varRoot.stack.push_back(content->idxs);`
`157`	`158`	`for (auto& it : content->elements()) it->accept(this);`
`158`		`- eval.compiler.varRoot.stack.pop_back();`
	`159`	`+ compiler.varRoot.stack.pop_back();`
`159`	`160`	`}`
`160`	`161`	`}`
`161`	`162`
`@@ -175,18 +176,18 @@ namespace Sass {`
`175`	`176`	`for (size_t i = 0; i < vars.size(); i += 1) {`
`176`	`177`	`idxs->varIdxs.insert({ vars[i], (uint32_t)i });`
`177`	`178`	`}`
`178`		`- eval.compiler.varRoot.stack.push_back(rule->idxs);`
	`179`	`+ compiler.varRoot.stack.push_back(rule->idxs);`
`179`	`180`	`for (auto& it : rule->elements()) it->accept(this);`
`180`		`- eval.compiler.varRoot.stack.pop_back();`
	`181`	`+ compiler.varRoot.stack.pop_back();`
`181`	`182`	`}`
`182`	`183`
`183`	`184`	`void Preloader::visitForRule(ForRule* rule)`
`184`	`185`	`{`
`185`	`186`	`LOCAL_PTR(EnvRefs, idxs, rule->idxs);`
`186`	`187`	`idxs->varIdxs.insert({ rule->varname(), 0 });`
`187`		`- eval.compiler.varRoot.stack.push_back(rule->idxs);`
	`188`	`+ compiler.varRoot.stack.push_back(rule->idxs);`
`188`	`189`	`for (auto& it : rule->elements()) it->accept(this);`
`189`		`- eval.compiler.varRoot.stack.pop_back();`
	`190`	`+ compiler.varRoot.stack.pop_back();`
`190`	`191`	`}`
`191`	`192`
`192`	`193`	`void Preloader::visitReturnRule(ReturnRule* rule)`