       @pattern1.contains(nodeName) or @pattern2.contains(nodeName)
     nullable: =>
       @pattern1.nullable() or @pattern2.nullable()
-    require: =>
-      p1 = @pattern1.require()
+    require: (node) =>
+      p1 = @pattern1.require(node)
       if p1 instanceof GoodElement
         return p1
-      p2 = @pattern2.require()
+      p2 = @pattern2.require(node)
       if p2 instanceof GoodElement
         return p2
       if p1 instanceof NotAllowed
-        if p2 instanceof Empty
+        if p2 instanceof Empty or p2 instanceof EmptyNode
           return new Empty("#{p2}", p2)
-        return new Choice(p1, new MissingContent("Missing: #{p2}", p2))
+        if p2 instanceof MissingContent and p1 instanceof MissingContent
+          return new MissingContent("#{p1} | #{p2}", new Choice(p1, p2), node)
+        return new NotAllowed("#{p1} | #{p2}", new Choice(p1, p2), node)
       if p2 instanceof NotAllowed
-        if p1 instanceof Empty
+        if p1 instanceof Empty or p2 instanceof EmptyNode
           return new Empty("#{p1}", p1)
-        return new Choice(new MissingContent("Missing: #{p1}"), p2)
-      if p2 instanceof Empty
+        return new NotAllowed("#{p1} | #{p2}", new Choice(p1, p2), node)
+      if p2 instanceof Empty or p2 instanceof EmptyNode
         return new Empty("#{p2}", p2)
       return p2
 
     _check: (node, descend) =>
-      if @pattern1 instanceof Empty and @pattern2 instanceof Attribute
-        return @pattern1
-      if @pattern2 instanceof Empty and @pattern1 instanceof Attribute
-        return @pattern2
+      if @pattern1 instanceof EmptyNode and @pattern2 instanceof Attribute
+        return @pattern1.check(node)
+      if @pattern2 instanceof EmptyNode and @pattern1 instanceof Attribute
+        return @pattern2.check(node)
       if @pattern1 instanceof GoodElement
         return @pattern1
       if @pattern2 instanceof GoodElement

            if nextPattern instanceof NotAllowed
              return nextPattern
        # TODO: Detect missing elements
        if nextPattern.require() instanceof Empty
          return new GoodElement(@name, nextPattern)
        else
          return nextPattern.require()
      else
        emptyPattern = new Empty("not descending into #{h.getLocalName(node)}", @pattern, node)
        return new GoodElement(emptyPattern, node)

      "(#{@pattern1} & #{@pattern2})"
    nullable: =>
      @pattern1.nullable() and @pattern2.nullable()
    require: (node) =>
      p1 = @pattern1.require(node)
      if p1 instanceof Empty
        return @pattern2.require(node)
      p2 = @pattern2.require(node)
      if p2 instanceof Empty
        return p1
      if p1 instanceof GoodElement and p2 instanceof GoodElement
