Fix @plugin scoping rules

bin/test.less

@@ -0,0 +1,11 @@
+#ns {
+	@plugin "../test/less/plugin/plugin-local";
+
+	.mixin() {
+		result : test-local();
+	}
+}
+
+.test {
+	#ns > .mixin();
+}

lib/less/tree/import.js

@@ -82,9 +82,11 @@ Import.prototype.isVariableImport = function () {
 };
 Import.prototype.evalForImport = function (context) {
     var path = this.path;
+
     if (path instanceof URL) {
         path = path.value;
     }
+
     return new Import(path.eval(context), this.features, this.options, this.index, this.currentFileInfo);
 };
 Import.prototype.evalPath = function (context) {
@@ -108,6 +110,14 @@ Import.prototype.eval = function (context) {
     var ruleset, registry,
         features = this.features && this.features.eval(context);
 
+    if (this.options.plugin) {
+        registry = context.frames[0] && context.frames[0].functionRegistry;
+        if ( registry && this.root && this.root.functions ) {
+            registry.addMultiple( this.root.functions );
+        }
+        return [];
+    }
+
     if (this.skip) {
         if (typeof this.skip === "function") {
             this.skip = this.skip();
@@ -117,13 +127,7 @@ Import.prototype.eval = function (context) {
         }
     }
 
-    if (this.options.plugin) {
-        registry = context.frames[0] && context.frames[0].functionRegistry;
-        if ( registry && this.root.functions ) {
-            registry.addMultiple( this.root.functions );
-        }
-        return [];
-    } else if (this.options.inline) {
+    if (this.options.inline) {
         var contents = new Anonymous(this.root, 0, {filename: this.importedFilename}, true, true);
         return this.features ? new Media([contents], this.features.value) : [contents];
     } else if (this.css) {

lib/less/tree/media.js

@@ -59,6 +59,7 @@ Media.prototype.eval = function (context) {
     context.mediaPath.push(media);
     context.mediaBlocks.push(media);
 
+    this.rules[0].functionRegistry = context.frames[0].functionRegistry.inherit();
     context.frames.unshift(this.rules[0]);
     media.rules = [this.rules[0].eval(context)];
     context.frames.shift();

lib/less/tree/mixin-definition.js

@@ -43,8 +43,10 @@ Definition.prototype.evalParams = function (context, mixinEnv, args, evaldArgume
         params = this.params.slice(0),
         i, j, val, name, isNamedFound, argIndex, argsLength = 0;
 
+    if (mixinEnv.frames && mixinEnv.frames[0] && mixinEnv.frames[0].functionRegistry) {
+        frame.functionRegistry = mixinEnv.frames[0].functionRegistry.inherit();
+    }
     mixinEnv = new contexts.Eval(mixinEnv, [frame].concat(mixinEnv.frames));
-    frame.functionRegistry = context.frames[0].functionRegistry.inherit();
 
     if (args) {
         args = args.slice(0);

lib/less/tree/ruleset.js

@@ -69,7 +69,16 @@ Ruleset.prototype.eval = function (context) {
 
     // inherit a function registry from the frames stack when possible;
     // otherwise from the global registry
-    ruleset.functionRegistry = ((context.frames[0] && context.frames[0].functionRegistry) || globalFunctionRegistry).inherit();
+    ruleset.functionRegistry = (function (frames) {
+        var i = 0,
+            n = frames.length,
+            found;
+        for ( ; i !== n ; ++i ) {
+            found = frames[ i ].functionRegistry;
+            if ( found ) { return found; }
+        }
+        return globalFunctionRegistry;
+    }(context.frames)).inherit();
 
     // push the current ruleset to the frames stack
     var ctxFrames = context.frames;

lib/less/visitors/import-visitor.js

@@ -103,6 +103,7 @@ ImportVisitor.prototype = {
 
         var importVisitor = this,
             inlineCSS = importNode.options.inline,
+            isPlugin = importNode.options.plugin,
             duplicateImport = importedAtRoot || fullPath in importVisitor.recursionDetector;
 
         if (!context.importMultiple) {
@@ -123,7 +124,7 @@ ImportVisitor.prototype = {
             importNode.root = root;
             importNode.importedFilename = fullPath;
 
-            if (!inlineCSS && (context.importMultiple || !duplicateImport)) {
+            if (!inlineCSS && !isPlugin && (context.importMultiple || !duplicateImport)) {
                 importVisitor.recursionDetector[fullPath] = true;
 
                 var oldContext = this.context;
@@ -144,7 +145,16 @@ ImportVisitor.prototype = {
         }
     },
     visitRule: function (ruleNode, visitArgs) {
-        visitArgs.visitDeeper = false;
+        if (ruleNode.value.type === "DetachedRuleset") {
+            this.context.frames.unshift(ruleNode);
+        } else {
+            visitArgs.visitDeeper = false;
+        }
+    },
+    visitRuleOut : function(ruleNode) {
+        if (ruleNode.value.type === "DetachedRuleset") {
+            this.context.frames.shift();
+        }
     },
     visitDirective: function (directiveNode, visitArgs) {
         this.context.frames.unshift(directiveNode);

test/css/plugin.css

@@ -0,0 +1,44 @@
+.other {
+  trans: transitive;
+}
+.class {
+  trans: transitive;
+  global: global;
+  local: test-local();
+  shadow: global;
+}
+.class .local {
+  global: global;
+  local: local;
+  shadow: local;
+}
+.class {
+  ns-mixin-global: global;
+  ns-mixin-local: local;
+  ns-mixin-shadow: local;
+  mixin-local: local;
+  mixin-global: global;
+  mixin-shadow: local;
+  ruleset-local: local;
+  ruleset-global: global;
+  ruleset-shadow: local;
+  class-local: test-local();
+}
+@media screen {
+  .test {
+    result: global;
+  }
+}
+@font-face {
+  result: global;
+}
+@media screen and (min-width: 100px) and (max-width: 400px) {
+  .test {
+    result: global;
+  }
+}
+@media screen {
+  .test {
+    result: local;
+  }
+}

test/less/plugin.less

@@ -0,0 +1,85 @@
+// importing plugin globally
+@plugin "./plugin/plugin-global";
+
+// transitively include plugins from importing another sheet
+@import "./plugin/plugin-transitive";
+
+
+// `test-global` function should be reachable
+// `test-local`  function should not be reachable
+// `test-shadow` function should return global version
+.class {
+  trans  : test-transitive();
+  global : test-global();
+  local  : test-local();
+  shadow : test-shadow();
+
+  // `test-global` function should propagate and be reachable
+  // `test-local`  function should be reachable
+  // `test-shadow` function should return local version, shadowing global version
+  .local {
+    @plugin "./plugin/plugin-local";
+    global : test-global();
+    local  : test-local();
+    shadow : test-shadow();
+  }
+}
+
+// calling a mixin or detached ruleset should not bubble local plugins
+// imported inside either into the parent scope.
+.mixin() {
+  @plugin "./plugin/plugin-local";
+  mixin-local  : test-local();
+  mixin-global : test-global();
+  mixin-shadow : test-shadow();
+}
+@ruleset : {
+  @plugin "./plugin/plugin-local";
+  ruleset-local  : test-local();
+  ruleset-global : test-global();
+  ruleset-shadow : test-shadow();
+};
+#ns {
+  @plugin "./plugin/plugin-local";
+  .mixin() {
+    ns-mixin-global : test-global();
+    ns-mixin-local  : test-local();
+    ns-mixin-shadow : test-shadow();
+  }
+}
+.class {
+  #ns > .mixin();
+  .mixin();
+  @ruleset();
+  class-local : test-local();
+}
+
+
+// `test-global` function should propagate into directive scope
+@media screen {
+  .test {
+    result : test-global();
+  }
+}
+@font-face {
+  result : test-global();
+}
+
+// `test-global` function should propagate into nested directive scopes
+@media screen and (min-width:100px) {
+  @media (max-width:400px) {
+		.test {
+			result : test-global();
+		}
+	}
+}
+
+.test {
+  @media screen {
+    @plugin "./plugin/plugin-local";
+    result : test-local();
+  }
+}
+
+
+

test/less/plugin/plugin-global.js

@@ -0,0 +1,9 @@
+
+functions.addMultiple({
+    "test-shadow" : function() {
+        return new tree.Anonymous( "global" );
+    },
+    "test-global" : function() {
+        return new tree.Anonymous( "global" );
+    }
+});

test/less/plugin/plugin-local.js

@@ -0,0 +1,8 @@
+functions.addMultiple({
+    "test-shadow" : function() {
+        return new tree.Anonymous( "local" );
+    },
+    "test-local" : function() {
+        return new tree.Anonymous( "local" );
+    }
+});

test/less/plugin/plugin-transitive.js

@@ -0,0 +1,5 @@
+functions.addMultiple({
+    "test-transitive" : function() {
+        return new tree.Anonymous( "transitive" );
+    }
+});

test/less/plugin/plugin-transitive.less

@@ -0,0 +1,5 @@
+@plugin "plugin-transitive";
+
+.other {
+  trans : test-transitive();
+}