Create a top-level "third_party" directory

This directory now contains third_party software that is vendored into
the Servo source tree. The idea is that it would eventually hold
webrender and other crates from mozilla-central as well with a standard
patch management approach for each.

third_party/WebIDL/tests/test_namespace.py

@@ -0,0 +1,232 @@
+def WebIDLTest(parser, harness):
+    parser.parse(
+        """
+        namespace MyNamespace {
+          attribute any foo;
+          any bar();
+        };
+        """
+    )
+
+    results = parser.finish()
+    harness.check(len(results), 1, "Should have a thing.")
+    harness.ok(results[0].isNamespace(), "Our thing should be a namespace")
+    harness.check(len(results[0].members), 2, "Should have two things in our namespace")
+    harness.ok(results[0].members[0].isAttr(), "First member is attribute")
+    harness.ok(results[0].members[0].isStatic(), "Attribute should be static")
+    harness.ok(results[0].members[1].isMethod(), "Second member is method")
+    harness.ok(results[0].members[1].isStatic(), "Operation should be static")
+
+    parser = parser.reset()
+    parser.parse(
+        """
+        namespace MyNamespace {
+          attribute any foo;
+        };
+        partial namespace MyNamespace {
+          any bar();
+        };
+        """
+    )
+
+    results = parser.finish()
+    harness.check(len(results), 2, "Should have things.")
+    harness.ok(results[0].isNamespace(), "Our thing should be a namespace")
+    harness.check(len(results[0].members), 2, "Should have two things in our namespace")
+    harness.ok(results[0].members[0].isAttr(), "First member is attribute")
+    harness.ok(results[0].members[0].isStatic(), "Attribute should be static")
+    harness.ok(results[0].members[1].isMethod(), "Second member is method")
+    harness.ok(results[0].members[1].isStatic(), "Operation should be static")
+
+    parser = parser.reset()
+    parser.parse(
+        """
+        partial namespace MyNamespace {
+          any bar();
+        };
+        namespace MyNamespace {
+          attribute any foo;
+        };
+        """
+    )
+
+    results = parser.finish()
+    harness.check(len(results), 2, "Should have things.")
+    harness.ok(results[1].isNamespace(), "Our thing should be a namespace")
+    harness.check(len(results[1].members), 2, "Should have two things in our namespace")
+    harness.ok(results[1].members[0].isAttr(), "First member is attribute")
+    harness.ok(results[1].members[0].isStatic(), "Attribute should be static")
+    harness.ok(results[1].members[1].isMethod(), "Second member is method")
+    harness.ok(results[1].members[1].isStatic(), "Operation should be static")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse(
+            """
+            namespace MyNamespace {
+              static attribute any foo;
+            };
+        """
+        )
+
+        results = parser.finish()
+    except Exception as x:
+        threw = True
+    harness.ok(threw, "Should have thrown.")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse(
+            """
+            namespace MyNamespace {
+              static any bar();
+            };
+        """
+        )
+
+        results = parser.finish()
+    except Exception as x:
+        threw = True
+    harness.ok(threw, "Should have thrown.")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse(
+            """
+            namespace MyNamespace {
+              any bar();
+            };
+
+            interface MyNamespace {
+              any baz();
+            };
+        """
+        )
+
+        results = parser.finish()
+    except Exception as x:
+        threw = True
+    harness.ok(threw, "Should have thrown.")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse(
+            """
+            interface MyNamespace {
+              any baz();
+            };
+
+            namespace MyNamespace {
+              any bar();
+            };
+        """
+        )
+
+        results = parser.finish()
+    except Exception as x:
+        threw = True
+    harness.ok(threw, "Should have thrown.")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse(
+            """
+            namespace MyNamespace {
+              any baz();
+            };
+
+            namespace MyNamespace {
+              any bar();
+            };
+        """
+        )
+
+        results = parser.finish()
+    except Exception as x:
+        threw = True
+    harness.ok(threw, "Should have thrown.")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse(
+            """
+            partial namespace MyNamespace {
+              any baz();
+            };
+
+            interface MyNamespace {
+              any bar();
+            };
+        """
+        )
+
+        results = parser.finish()
+    except Exception as x:
+        threw = True
+    harness.ok(threw, "Should have thrown.")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse(
+            """
+            namespace MyNamespace {
+              any bar();
+            };
+
+            partial interface MyNamespace {
+              any baz();
+            };
+        """
+        )
+
+        results = parser.finish()
+    except Exception as x:
+        threw = True
+    harness.ok(threw, "Should have thrown.")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse(
+            """
+            partial interface MyNamespace {
+              any baz();
+            };
+
+            namespace MyNamespace {
+              any bar();
+            };
+        """
+        )
+
+        results = parser.finish()
+    except Exception as x:
+        threw = True
+    harness.ok(threw, "Should have thrown.")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse(
+            """
+            interface MyNamespace {
+              any bar();
+            };
+
+            partial namespace MyNamespace {
+              any baz();
+            };
+        """
+        )
+
+        results = parser.finish()
+    except Exception as x:
+        threw = True
+    harness.ok(threw, "Should have thrown.")