Index: django/template/defaulttags.py
===================================================================
--- django/template/defaulttags.py	(revision 7547)
+++ django/template/defaulttags.py	(working copy)
@@ -38,13 +38,13 @@
         return ''
 
 class CycleNode(Node):
-    def __init__(self, cyclevars, variable_name=None):
-        self.cycle_iter = itertools_cycle(cyclevars)
+    def __init__(self, cyclevals, variable_name=None):
+        self.cycle_iter = itertools_cycle(cyclevals)
         self.variable_name = variable_name
 
     def render(self, context):
         value = self.cycle_iter.next()
-        value = Variable(value).resolve(context)
+        value = value.resolve(context, True)
         if self.variable_name:
             context[self.variable_name] = value
         return value
@@ -70,15 +70,12 @@
         return filtered
 
 class FirstOfNode(Node):
-    def __init__(self, vars):
-        self.vars = map(Variable, vars)
+    def __init__(self, vals):
+        self.vals = vals
 
     def render(self, context):
-        for var in self.vars:
-            try:
-                value = var.resolve(context)
-            except VariableDoesNotExist:
-                continue
+        for val in self.vals:
+            value = val.resolve(context, True)
             if value:
                 return smart_unicode(value)
         return u''
@@ -158,19 +155,19 @@
         return nodelist.render(context)
 
 class IfChangedNode(Node):
-    def __init__(self, nodelist, *varlist):
+    def __init__(self, nodelist, *vallist):
         self.nodelist = nodelist
         self._last_seen = None
-        self._varlist = map(Variable, varlist)
+        self._vallist = vallist
 
     def render(self, context):
         if 'forloop' in context and context['forloop']['first']:
             self._last_seen = None
         try:
-            if self._varlist:
+            if self._vallist:
                 # Consider multiple parameters.  This automatically behaves
                 # like an OR evaluation of the multiple variables.
-                compare_to = [var.resolve(context) for var in self._varlist]
+                compare_to = [val.resolve(context, True) for val in self._vallist]
             else:
                 compare_to = self.nodelist.render(context)
         except VariableDoesNotExist:
@@ -188,8 +185,8 @@
             return ''
 
 class IfEqualNode(Node):
-    def __init__(self, var1, var2, nodelist_true, nodelist_false, negate):
-        self.var1, self.var2 = Variable(var1), Variable(var2)
+    def __init__(self, val1, val2, nodelist_true, nodelist_false, negate):
+        self.val1, self.val2 = val1, val2
         self.nodelist_true, self.nodelist_false = nodelist_true, nodelist_false
         self.negate = negate
 
@@ -197,14 +194,7 @@
         return "<IfEqualNode>"
 
     def render(self, context):
-        try:
-            val1 = self.var1.resolve(context)
-        except VariableDoesNotExist:
-            val1 = None
-        try:
-            val2 = self.var2.resolve(context)
-        except VariableDoesNotExist:
-            val2 = None
+        val1, val2 = (self.val1.resolve(context, True), self.val2.resolve(context, True))
         if (self.negate and val1 != val2) or (not self.negate and val1 == val2):
             return self.nodelist_true.render(context)
         return self.nodelist_false.render(context)
@@ -489,12 +479,14 @@
 
     if len(args) > 4 and args[-2] == 'as':
         name = args[-1]
-        node = CycleNode(args[1:-2], name)
+        values = [parser.compile_filter(arg) for arg in args[1:-2]]
+        node = CycleNode(values, name)
         if not hasattr(parser, '_namedCycleNodes'):
             parser._namedCycleNodes = {}
         parser._namedCycleNodes[name] = node
     else:
-        node = CycleNode(args[1:])
+        values = [parser.compile_filter(arg) for arg in args[1:]]
+        node = CycleNode(values)
     return node
 cycle = register.tag(cycle)
 
@@ -569,7 +561,8 @@
     if len(bits) < 1:
         raise TemplateSyntaxError("'firstof' statement requires at least one"
                                   " argument")
-    return FirstOfNode(bits)
+    values = [parser.compile_filter(bit) for bit in bits]
+    return FirstOfNode(values)
 firstof = register.tag(firstof)
 
 #@register.tag(name="for")
@@ -640,6 +633,8 @@
     if len(bits) != 3:
         raise TemplateSyntaxError, "%r takes two arguments" % bits[0]
     end_tag = 'end' + bits[0]
+    val1 = parser.compile_filter(bits[1])
+    val2 = parser.compile_filter(bits[2])
     nodelist_true = parser.parse(('else', end_tag))
     token = parser.next_token()
     if token.contents == 'else':
@@ -647,7 +642,7 @@
         parser.delete_first_token()
     else:
         nodelist_false = NodeList()
-    return IfEqualNode(bits[1], bits[2], nodelist_true, nodelist_false, negate)
+    return IfEqualNode(val1, val2, nodelist_true, nodelist_false, negate)
 
 #@register.tag
 def ifequal(parser, token):
@@ -803,7 +798,8 @@
     bits = token.contents.split()
     nodelist = parser.parse(('endifchanged',))
     parser.delete_first_token()
-    return IfChangedNode(nodelist, *bits[1:])
+    values = [parser.compile_filter(bit) for bit in bits[1:]]
+    return IfChangedNode(nodelist, *values)
 ifchanged = register.tag(ifchanged)
 
 #@register.tag
Index: django/template/loader_tags.py
===================================================================
--- django/template/loader_tags.py	(revision 7547)
+++ django/template/loader_tags.py	(working copy)
@@ -110,11 +110,11 @@
 
 class IncludeNode(Node):
     def __init__(self, template_name):
-        self.template_name = Variable(template_name)
+        self.template_name = template_name
 
     def render(self, context):
         try:
-            template_name = self.template_name.resolve(context)
+            template_name = self.template_name.resolve(context, True)
             t = get_template(template_name)
             return t.render(context)
         except TemplateSyntaxError, e:
@@ -181,7 +181,8 @@
     path = bits[1]
     if path[0] in ('"', "'") and path[-1] == path[0]:
         return ConstantIncludeNode(path[1:-1])
-    return IncludeNode(bits[1])
+    path_value = parser.compile_filter(path)
+    return IncludeNode(path_value)
 
 register.tag('block', do_block)
 register.tag('extends', do_extends)