update sdlang, start looking to using dub remote dependenciesdoc-reform_v0.0.6

1 files changed, 1193 insertions, 82 deletions

diff --git a/src/sdlang/ast.d b/src/sdlang/ast.d
index 7ad1c30..87dd0bd 100644
--- a/src/sdlang/ast.d
+++ b/src/sdlang/ast.d
@@ -9,13 +9,6 @@ import std.conv;
 import std.range;
 import std.string;
 
-version(sdlangUnittest)
-version(unittest)
-{
-	import std.stdio;
-	import std.exception;
-}
-
 import sdlang.exception;
 import sdlang.token;
 import sdlang.util;
@@ -27,7 +20,7 @@ class Attribute
 	
 	private Tag _parent;
 	/// Get parent tag. To set a parent, attach this Attribute to its intended
-	/// parent tag by calling 'Tag.add(...)', or by passing it to
+	/// parent tag by calling `Tag.add(...)`, or by passing it to
 	/// the parent tag's constructor.
 	@property Tag parent()
 	{
@@ -35,11 +28,20 @@ class Attribute
 	}
 
 	private string _namespace;
+	/++
+	This tag's namespace. Empty string if no namespace.
+	
+	Note that setting this value is O(n) because internal lookup structures 
+	need to be updated.
+	
+	Note also, that setting this may change where this tag is ordered among
+	its parent's list of tags.
+	+/
 	@property string namespace()
 	{
 		return _namespace;
 	}
-	/// Not particularly efficient, but it works.
+	///ditto
 	@property void namespace(string value)
 	{
 		if(_parent && _namespace != value)
@@ -61,12 +63,22 @@ class Attribute
 	}
 	
 	private string _name;
-	/// Not including namespace. Use 'fullName' if you want the namespace included.
+	/++
+	This attribute's name, not including namespace.
+	
+	Use `getFullName().toString` if you want the namespace included.
+	
+	Note that setting this value is O(n) because internal lookup structures 
+	need to be updated.
+
+	Note also, that setting this may change where this attribute is ordered
+	among its parent's list of tags.
+	+/
 	@property string name()
 	{
 		return _name;
 	}
-	/// Not the most efficient, but it works.
+	///ditto
 	@property void name(string value)
 	{
 		if(_parent && _name != value)
@@ -96,9 +108,17 @@ class Attribute
 			_name = value;
 	}
 
+	/// This tag's name, including namespace if one exists.
+	deprecated("Use 'getFullName().toString()'")
 	@property string fullName()
 	{
-		return _namespace==""? _name : text(_namespace, ":", _name);
+		return getFullName().toString();
+	}
+	
+	/// This tag's name, including namespace if one exists.
+	FullName getFullName()
+	{
+		return FullName(_namespace, _name);
 	}
 
 	this(string namespace, string name, Value value, Location location = Location(0, 0, 0))
@@ -117,7 +137,14 @@ class Attribute
 		this.value      = value;
 	}
 	
-	/// Removes 'this' from its parent, if any. Returns 'this' for chaining.
+	/// Copy this Attribute.
+	/// The clone does $(B $(I not)) have a parent, even if the original does.
+	Attribute clone()
+	{
+		return new Attribute(_namespace, _name, value, location);
+	}
+	
+	/// Removes `this` from its parent, if any. Returns `this` for chaining.
 	/// Inefficient ATM, but it works.
 	Attribute remove()
 	{
@@ -190,14 +217,31 @@ class Attribute
 	}
 }
 
+/// Deep-copy an array of Tag or Attribute.
+/// The top-level clones are $(B $(I not)) attached to any parent, even if the originals are.
+T[] clone(T)(T[] arr) if(is(T==Tag) || is(T==Attribute))
+{
+	T[] newArr;
+	newArr.length = arr.length;
+	
+	foreach(i; 0..arr.length)
+		newArr[i] = arr[i].clone();
+	
+	return newArr;
+}
+
 class Tag
 {
+	/// File/Line/Column/Index information for where this tag was located in
+	/// its original SDLang file.
 	Location location;
+	
+	/// Access all this tag's values, as an array of type `sdlang.token.Value`.
 	Value[]  values;
 
 	private Tag _parent;
 	/// Get parent tag. To set a parent, attach this Tag to its intended
-	/// parent tag by calling 'Tag.add(...)', or by passing it to
+	/// parent tag by calling `Tag.add(...)`, or by passing it to
 	/// the parent tag's constructor.
 	@property Tag parent()
 	{
@@ -205,13 +249,24 @@ class Tag
 	}
 
 	private string _namespace;
+	/++
+	This tag's namespace. Empty string if no namespace.
+	
+	Note that setting this value is O(n) because internal lookup structures 
+	need to be updated.
+	
+	Note also, that setting this may change where this tag is ordered among
+	its parent's list of tags.
+	+/
 	@property string namespace()
 	{
 		return _namespace;
 	}
-	/// Not particularly efficient, but it works.
+	///ditto
 	@property void namespace(string value)
 	{
+		//TODO: Can we do this in-place, without removing/adding and thus
+		//      modyfying the internal order?
 		if(_parent && _namespace != value)
 		{
 			// Remove
@@ -231,18 +286,31 @@ class Tag
 	}
 	
 	private string _name;
-	/// Not including namespace. Use 'fullName' if you want the namespace included.
+	/++
+	This tag's name, not including namespace.
+	
+	Use `getFullName().toString` if you want the namespace included.
+	
+	Note that setting this value is O(n) because internal lookup structures 
+	need to be updated.
+
+	Note also, that setting this may change where this tag is ordered among
+	its parent's list of tags.
+	+/
 	@property string name()
 	{
 		return _name;
 	}
-	/// Not the most efficient, but it works.
+	///ditto
 	@property void name(string value)
 	{
+		//TODO: Seriously? Can't we at least do the "*" modification *in-place*?
+		
 		if(_parent && _name != value)
 		{
 			_parent.updateId++;
 			
+			// Not the most efficient, but it works.
 			void removeFromGroupedLookup(string ns)
 			{
 				// Remove from _parent._tags[ns]
@@ -259,6 +327,7 @@ class Tag
 			_name = value;
 			
 			// Add to new locations in _parent._tags
+			//TODO: Can we re-insert while preserving the original order?
 			_parent._tags[_namespace][_name] ~= this;
 			_parent._tags["*"][_name] ~= this;
 		}
@@ -267,11 +336,18 @@ class Tag
 	}
 	
 	/// This tag's name, including namespace if one exists.
+	deprecated("Use 'getFullName().toString()'")
 	@property string fullName()
 	{
-		return _namespace==""? _name : text(_namespace, ":", _name);
+		return getFullName().toString();
 	}
-
+	
+	/// This tag's name, including namespace if one exists.
+	FullName getFullName()
+	{
+		return FullName(_namespace, _name);
+	}
+	
 	// Tracks dirtiness. This is incremented every time a change is made which
 	// could invalidate existing ranges. This way, the ranges can detect when
 	// they've been invalidated.
@@ -307,6 +383,15 @@ class Tag
 		this.add(children);
 	}
 
+	/// Deep-copy this Tag.
+	/// The clone does $(B $(I not)) have a parent, even if the original does.
+	Tag clone()
+	{
+		auto newTag = new Tag(_namespace, _name, values.dup, allAttributes.clone(), allTags.clone());
+		newTag.location = location;
+		return newTag;
+	}
+	
 	private Attribute[] allAttributes; // In same order as specified in SDL file.
 	private Tag[]       allTags;       // In same order as specified in SDL file.
 	private string[]    allNamespaces; // In same order as specified in SDL file.
@@ -318,8 +403,8 @@ class Tag
 	private Tag[][string][string]       _tags;       // tags[namespace or "*"][name][i]
 	
 	/// Adds a Value, Attribute, Tag (or array of such) as a member/child of this Tag.
-	/// Returns 'this' for chaining.
-	/// Throws 'SDLangValidationException' if trying to add an Attribute or Tag
+	/// Returns `this` for chaining.
+	/// Throws `ValidationException` if trying to add an Attribute or Tag
 	/// that already has a parent.
 	Tag add(Value val)
 	{
@@ -342,7 +427,7 @@ class Tag
 	{
 		if(attr._parent)
 		{
-			throw new SDLangValidationException(
+			throw new ValidationException(
 				"Attribute is already attached to a parent tag. "~
 				"Use Attribute.remove() before adding it to another tag."
 			);
@@ -376,7 +461,7 @@ class Tag
 	{
 		if(tag._parent)
 		{
-			throw new SDLangValidationException(
+			throw new ValidationException(
 				"Tag is already attached to a parent tag. "~
 				"Use Tag.remove() before adding it to another tag."
 			);
@@ -405,7 +490,7 @@ class Tag
 		return this;
 	}
 	
-	/// Removes 'this' from its parent, if any. Returns 'this' for chaining.
+	/// Removes `this` from its parent, if any. Returns `this` for chaining.
 	/// Inefficient ATM, but it works.
 	Tag remove()
 	{
@@ -488,6 +573,7 @@ class Tag
 			frontIndex = 0;
 
 			if(
+				tag !is null &&
 				namespace in mixin("tag."~membersGrouped) &&
 				name in mixin("tag."~membersGrouped~"[namespace]")
 			)
@@ -506,7 +592,7 @@ class Tag
 
 		@property bool empty()
 		{
-			return frontIndex == endIndex;
+			return tag is null || frontIndex == endIndex;
 		}
 		
 		private size_t frontIndex;
@@ -517,7 +603,7 @@ class Tag
 		void popFront()
 		{
 			if(empty)
-				throw new SDLangRangeException("Range is empty");
+				throw new DOMRangeException(tag, "Range is empty");
 
 			frontIndex++;
 		}
@@ -530,7 +616,7 @@ class Tag
 		void popBack()
 		{
 			if(empty)
-				throw new SDLangRangeException("Range is empty");
+				throw new DOMRangeException(tag, "Range is empty");
 
 			endIndex--;
 		}
@@ -565,7 +651,7 @@ class Tag
 				r.endIndex > this.endIndex ||
 				r.frontIndex > r.endIndex
 			)
-				throw new SDLangRangeException("Slice out of range");
+				throw new DOMRangeException(tag, "Slice out of range");
 			
 			return r;
 		}
@@ -573,7 +659,7 @@ class Tag
 		T opIndex(size_t index)
 		{
 			if(empty)
-				throw new SDLangRangeException("Range is empty");
+				throw new DOMRangeException(tag, "Range is empty");
 
 			return mixin("tag."~membersGrouped~"[namespace][name][frontIndex+index]");
 		}
@@ -595,14 +681,20 @@ class Tag
 			this.isMaybe   = isMaybe;
 			frontIndex = 0;
 
-			if(namespace == "*")
-				initialEndIndex = mixin("tag."~allMembers~".length");
-			else if(namespace in mixin("tag."~memberIndicies))
-				initialEndIndex = mixin("tag."~memberIndicies~"[namespace].length");
+			if(tag is null)
+				endIndex = 0;
 			else
-				initialEndIndex = 0;
+			{
+
+				if(namespace == "*")
+					initialEndIndex = mixin("tag."~allMembers~".length");
+				else if(namespace in mixin("tag."~memberIndicies))
+					initialEndIndex = mixin("tag."~memberIndicies~"[namespace].length");
+				else
+					initialEndIndex = 0;
 			
-			endIndex = initialEndIndex;
+				endIndex = initialEndIndex;
+			}
 		}
 		
 		invariant()
@@ -615,7 +707,7 @@ class Tag
 
 		@property bool empty()
 		{
-			return frontIndex == endIndex;
+			return tag is null || frontIndex == endIndex;
 		}
 		
 		private size_t frontIndex;
@@ -626,7 +718,7 @@ class Tag
 		void popFront()
 		{
 			if(empty)
-				throw new SDLangRangeException("Range is empty");
+				throw new DOMRangeException(tag, "Range is empty");
 
 			frontIndex++;
 		}
@@ -639,7 +731,7 @@ class Tag
 		void popBack()
 		{
 			if(empty)
-				throw new SDLangRangeException("Range is empty");
+				throw new DOMRangeException(tag, "Range is empty");
 
 			endIndex--;
 		}
@@ -676,7 +768,7 @@ class Tag
 				r.endIndex > this.endIndex ||
 				r.frontIndex > r.endIndex
 			)
-				throw new SDLangRangeException("Slice out of range");
+				throw new DOMRangeException(tag, "Slice out of range");
 			
 			return r;
 		}
@@ -684,7 +776,7 @@ class Tag
 		T opIndex(size_t index)
 		{
 			if(empty)
-				throw new SDLangRangeException("Range is empty");
+				throw new DOMRangeException(tag, "Range is empty");
 
 			if(namespace == "*")
 				return mixin("tag."~allMembers~"[ frontIndex+index ]");
@@ -697,7 +789,7 @@ class Tag
 		{
 			if(frontIndex != 0 || endIndex != initialEndIndex)
 			{
-				throw new SDLangRangeException(
+				throw new DOMRangeException(tag,
 					"Cannot lookup tags/attributes by name on a subset of a range, "~
 					"only across the entire tag. "~
 					"Please make sure you haven't called popFront or popBack on this "~
@@ -706,10 +798,10 @@ class Tag
 			}
 			
 			if(!isMaybe && empty)
-				throw new SDLangRangeException("Range is empty");
+				throw new DOMRangeException(tag, "Range is empty");
 			
 			if(!isMaybe && name !in this)
-				throw new SDLangRangeException(`No such `~T.stringof~` named: "`~name~`"`);
+				throw new DOMRangeException(tag, `No such `~T.stringof~` named: "`~name~`"`);
 
 			return ThisNamedMemberRange(tag, namespace, name, updateId);
 		}
@@ -718,7 +810,7 @@ class Tag
 		{
 			if(frontIndex != 0 || endIndex != initialEndIndex)
 			{
-				throw new SDLangRangeException(
+				throw new DOMRangeException(tag,
 					"Cannot lookup tags/attributes by name on a subset of a range, "~
 					"only across the entire tag. "~
 					"Please make sure you haven't called popFront or popBack on this "~
@@ -726,6 +818,9 @@ class Tag
 				);
 			}
 			
+			if(tag is null)
+				return false;
+			
 			return
 				namespace in mixin("tag."~membersGrouped) &&
 				name in mixin("tag."~membersGrouped~"[namespace]") && 
@@ -769,7 +864,7 @@ class Tag
 		void popFront()
 		{
 			if(empty)
-				throw new SDLangRangeException("Range is empty");
+				throw new DOMRangeException(tag, "Range is empty");
 			
 			frontIndex++;
 		}
@@ -782,7 +877,7 @@ class Tag
 		void popBack()
 		{
 			if(empty)
-				throw new SDLangRangeException("Range is empty");
+				throw new DOMRangeException(tag, "Range is empty");
 			
 			endIndex--;
 		}
@@ -818,7 +913,7 @@ class Tag
 				r.endIndex > this.endIndex ||
 				r.frontIndex > r.endIndex
 			)
-				throw new SDLangRangeException("Slice out of range");
+				throw new DOMRangeException(tag, "Slice out of range");
 			
 			return r;
 		}
@@ -826,7 +921,7 @@ class Tag
 		NamespaceAccess opIndex(size_t index)
 		{
 			if(empty)
-				throw new SDLangRangeException("Range is empty");
+				throw new DOMRangeException(tag, "Range is empty");
 
 			auto namespace = tag.allNamespaces[frontIndex+index];
 			return NamespaceAccess(
@@ -839,10 +934,10 @@ class Tag
 		NamespaceAccess opIndex(string namespace)
 		{
 			if(!isMaybe && empty)
-				throw new SDLangRangeException("Range is empty");
+				throw new DOMRangeException(tag, "Range is empty");
 			
 			if(!isMaybe && namespace !in this)
-				throw new SDLangRangeException(`No such namespace: "`~namespace~`"`);
+				throw new DOMRangeException(tag, `No such namespace: "`~namespace~`"`);
 			
 			return NamespaceAccess(
 				namespace,
@@ -866,7 +961,7 @@ class Tag
 		}
 	}
 
-	struct NamespaceAccess
+	static struct NamespaceAccess
 	{
 		string name;
 		AttributeRange attributes;
@@ -879,25 +974,66 @@ class Tag
 	static assert(isRandomAccessRange!TagRange);
 	static assert(isRandomAccessRange!NamespaceRange);
 
-	/// Access all attributes that don't have a namespace
+	/++
+	Access all attributes that don't have a namespace
+
+	Returns a random access range of `Attribute` objects that supports
+	numeric-indexing, string-indexing, slicing and length.
+	
+	Since SDLang allows multiple attributes with the same name,
+	string-indexing returns a random access range of all attributes
+	with the given name.
+	
+	The string-indexing does $(B $(I not)) support namespace prefixes.
+	Use `namespace[string]`.`attributes` or `all`.`attributes` for that.
+	
+	See $(LINK2 https://github.com/Abscissa/SDLang-D/blob/master/HOWTO.md#tag-and-attribute-api-summary, API Overview)
+	for a high-level overview (and examples) of how to use this.
+	+/
 	@property AttributeRange attributes()
 	{
 		return AttributeRange(this, "", false);
 	}
 
-	/// Access all direct-child tags that don't have a namespace
+	/++
+	Access all direct-child tags that don't have a namespace.
+	
+	Returns a random access range of `Tag` objects that supports
+	numeric-indexing, string-indexing, slicing and length.
+	
+	Since SDLang allows multiple tags with the same name, string-indexing
+	returns a random access range of all immediate child tags with the
+	given name.
+	
+	The string-indexing does $(B $(I not)) support namespace prefixes.
+	Use `namespace[string]`.`attributes` or `all`.`attributes` for that.
+	
+	See $(LINK2 https://github.com/Abscissa/SDLang-D/blob/master/HOWTO.md#tag-and-attribute-api-summary, API Overview)
+	for a high-level overview (and examples) of how to use this.
+	+/
 	@property TagRange tags()
 	{
 		return TagRange(this, "", false);
 	}
 	
-	/// Access all namespaces in this tag, and the attributes/tags within them.
+	/++
+	Access all namespaces in this tag, and the attributes/tags within them.
+	
+	Returns a random access range of `NamespaceAccess` elements that supports
+	numeric-indexing, string-indexing, slicing and length.
+	
+	See $(LINK2 https://github.com/Abscissa/SDLang-D/blob/master/HOWTO.md#tag-and-attribute-api-summary, API Overview)
+	for a high-level overview (and examples) of how to use this.
+	+/
 	@property NamespaceRange namespaces()
 	{
 		return NamespaceRange(this, false);
 	}
 
 	/// Access all attributes and tags regardless of namespace.
+	///
+	/// See $(LINK2 https://github.com/Abscissa/SDLang-D/blob/master/HOWTO.md#tag-and-attribute-api-summary, API Overview)
+	/// for a better understanding (and examples) of how to use this.
 	@property NamespaceAccess all()
 	{
 		// "*" isn't a valid namespace name, so we can use it to indicate "all namespaces"
@@ -942,14 +1078,972 @@ class Tag
 		}
 	}
 	
-	/// Access 'attributes', 'tags', 'namespaces' and 'all' like normal,
+	/// Access `attributes`, `tags`, `namespaces` and `all` like normal,
 	/// except that looking up a non-existant name/namespace with
-	/// opIndex(string) results in an empty array instead of a thrown SDLangRangeException.
+	/// opIndex(string) results in an empty array instead of
+	/// a thrown `sdlang.exception.DOMRangeException`.
+	///
+	/// See $(LINK2 https://github.com/Abscissa/SDLang-D/blob/master/HOWTO.md#tag-and-attribute-api-summary, API Overview)
+	/// for a more information (and examples) of how to use this.
 	@property MaybeAccess maybe()
 	{
 		return MaybeAccess(this);
 	}
 	
+	// Internal implementations for the get/expect functions further below:
+	
+	private Tag getTagImpl(FullName tagFullName, Tag defaultValue=null, bool useDefaultValue=true)
+	{
+		auto tagNS   = tagFullName.namespace;
+		auto tagName = tagFullName.name;
+		
+		// Can find namespace?
+		if(tagNS !in _tags)
+		{
+			if(useDefaultValue)
+				return defaultValue;
+			else
+				throw new TagNotFoundException(this, tagFullName, "No tags found in namespace '"~namespace~"'");
+		}
+
+		// Can find tag in namespace?
+		if(tagName !in _tags[tagNS] || _tags[tagNS][tagName].length == 0)
+		{
+			if(useDefaultValue)
+				return defaultValue;
+			else
+				throw new TagNotFoundException(this, tagFullName, "Can't find tag '"~tagFullName.toString()~"'");
+		}
+
+		// Return last matching tag found
+		return _tags[tagNS][tagName][$-1];
+	}
+
+	private T getValueImpl(T)(T defaultValue, bool useDefaultValue=true)
+	if(isValueType!T)
+	{
+		// Find value
+		foreach(value; this.values)
+		{
+			if(value.type == typeid(T))
+				return value.get!T();
+		}
+		
+		// No value of type T found
+		if(useDefaultValue)
+			return defaultValue;
+		else
+		{
+			throw new ValueNotFoundException(
+				this,
+				FullName(this.namespace, this.name),
+				typeid(T),
+				"No value of type "~T.stringof~" found."
+			);
+		}
+	}
+
+	private T getAttributeImpl(T)(FullName attrFullName, T defaultValue, bool useDefaultValue=true)
+	if(isValueType!T)
+	{
+		auto attrNS   = attrFullName.namespace;
+		auto attrName = attrFullName.name;
+		
+		// Can find namespace and attribute name?
+		if(attrNS !in this._attributes || attrName !in this._attributes[attrNS])
+		{
+			if(useDefaultValue)
+				return defaultValue;
+			else
+			{
+				throw new AttributeNotFoundException(
+					this, this.getFullName(), attrFullName, typeid(T),
+					"Can't find attribute '"~FullName.combine(attrNS, attrName)~"'"
+				);
+			}
+		}
+
+		// Find value with chosen type
+		foreach(attr; this._attributes[attrNS][attrName])
+		{
+			if(attr.value.type == typeid(T))
+				return attr.value.get!T();
+		}
+		
+		// Chosen type not found
+		if(useDefaultValue)
+			return defaultValue;
+		else
+		{
+			throw new AttributeNotFoundException(
+				this, this.getFullName(), attrFullName, typeid(T),
+				"Can't find attribute '"~FullName.combine(attrNS, attrName)~"' of type "~T.stringof
+			);
+		}
+	}
+
+	// High-level interfaces for get/expect funtions:
+	
+	/++
+	Lookup a child tag by name. Returns null if not found.
+	
+	Useful if you only expect one, and only one, child tag of a given name.
+	Only looks for immediate child tags of `this`, doesn't search recursively.
+	
+	If you expect multiple tags by the same name and want to get them all,
+	use `maybe`.`tags[string]` instead.
+	
+	The name can optionally include a namespace, as in `"namespace:name"`.
+	Or, you can search all namespaces using `"*:name"`. Use an empty string
+	to search for anonymous tags, or `"namespace:"` for anonymous tags inside
+	a namespace. Wildcard searching is only supported for namespaces, not names.
+	Use `maybe`.`tags[0]` if you don't care about the name.
+	
+	If there are multiple tags by the chosen name, the $(B $(I last tag)) will
+	always be chosen. That is, this function considers later tags with the
+	same name to override previous ones.
+	
+	If the tag cannot be found, and you provides a default value, the default
+	value is returned. Otherwise null is returned. If you'd prefer an
+	exception thrown, use `expectTag` instead.
+	+/
+	Tag getTag(string fullTagName, Tag defaultValue=null)
+	{
+		auto parsedName = FullName.parse(fullTagName);
+		parsedName.ensureNoWildcardName(
+			"Instead, use 'Tag.maybe.tags[0]', 'Tag.maybe.all.tags[0]' or 'Tag.maybe.namespace[ns].tags[0]'."
+		);
+		return getTagImpl(parsedName, defaultValue);
+	}
+	
+	///
+	@("Tag.getTag")
+	unittest
+	{
+		import std.exception;
+		import sdlang.parser;
+		
+		auto root = parseSource(`
+			foo 1
+			foo 2  // getTag considers this to override the first foo
+
+			ns1:foo 3
+			ns1:foo 4   // getTag considers this to override the first ns1:foo
+			ns2:foo 33
+			ns2:foo 44  // getTag considers this to override the first ns2:foo
+		`);
+		assert( root.getTag("foo"    ).values[0].get!int() == 2  );
+		assert( root.getTag("ns1:foo").values[0].get!int() == 4  );
+		assert( root.getTag("*:foo"  ).values[0].get!int() == 44 ); // Search all namespaces
+		
+		// Not found
+		// If you'd prefer an exception, use `expectTag` instead.
+		assert( root.getTag("doesnt-exist") is null );
+
+		// Default value
+		auto foo = root.getTag("foo");
+		assert( root.getTag("doesnt-exist", foo) is foo );
+	}
+	
+	/++
+	Lookup a child tag by name. Throws if not found.
+	
+	Useful if you only expect one, and only one, child tag of a given name.
+	Only looks for immediate child tags of `this`, doesn't search recursively.
+	
+	If you expect multiple tags by the same name and want to get them all,
+	use `tags[string]` instead.
+
+	The name can optionally include a namespace, as in `"namespace:name"`.
+	Or, you can search all namespaces using `"*:name"`. Use an empty string
+	to search for anonymous tags, or `"namespace:"` for anonymous tags inside
+	a namespace. Wildcard searching is only supported for namespaces, not names.
+	Use `tags[0]` if you don't care about the name.
+	
+	If there are multiple tags by the chosen name, the $(B $(I last tag)) will
+	always be chosen. That is, this function considers later tags with the
+	same name to override previous ones.
+	
+	If no such tag is found, an `sdlang.exception.TagNotFoundException` will
+	be thrown. If you'd rather receive a default value, use `getTag` instead.
+	+/
+	Tag expectTag(string fullTagName)
+	{
+		auto parsedName = FullName.parse(fullTagName);
+		parsedName.ensureNoWildcardName(
+			"Instead, use 'Tag.tags[0]', 'Tag.all.tags[0]' or 'Tag.namespace[ns].tags[0]'."
+		);
+		return getTagImpl(parsedName, null, false);
+	}
+	
+	///
+	@("Tag.expectTag")
+	unittest
+	{
+		import std.exception;
+		import sdlang.parser;
+		
+		auto root = parseSource(`
+			foo 1
+			foo 2  // expectTag considers this to override the first foo
+
+			ns1:foo 3
+			ns1:foo 4   // expectTag considers this to override the first ns1:foo
+			ns2:foo 33
+			ns2:foo 44  // expectTag considers this to override the first ns2:foo
+		`);
+		assert( root.expectTag("foo"    ).values[0].get!int() == 2  );
+		assert( root.expectTag("ns1:foo").values[0].get!int() == 4  );
+		assert( root.expectTag("*:foo"  ).values[0].get!int() == 44 ); // Search all namespaces
+		
+		// Not found
+		// If you'd rather receive a default value than an exception, use `getTag` instead.
+		assertThrown!TagNotFoundException( root.expectTag("doesnt-exist") );
+	}
+	
+	/++
+	Retrieve a value of type T from `this` tag. Returns a default value if not found.
+	
+	Useful if you only expect one value of type T from this tag. Only looks for
+	values of `this` tag, it does not search child tags. If you wish to search
+	for a value in a child tag (for example, if this current tag is a root tag),
+	try `getTagValue`.
+
+	If you want to get more than one value from this tag, use `values` instead.
+
+	If this tag has multiple values, the $(B $(I first)) value matching the
+	requested type will be returned. Ie, Extra values in the tag are ignored.
+	
+	You may provide a default value to be returned in case no value of
+	the requested type can be found. If you don't provide a default value,
+	`T.init` will be used.
+	
+	If you'd rather an exception be thrown when a value cannot be found,
+	use `expectValue` instead.
+	+/
+	T getValue(T)(T defaultValue = T.init) if(isValueType!T)
+	{
+		return getValueImpl!T(defaultValue, true);
+	}
+
+	///
+	@("Tag.getValue")
+	unittest
+	{
+		import std.exception;
+		import std.math;
+		import sdlang.parser;
+		
+		auto root = parseSource(`
+			foo 1 true 2 false
+		`);
+		auto foo = root.getTag("foo");
+		assert( foo.getValue!int() == 1 );
+		assert( foo.getValue!bool() == true );
+
+		// Value found, default value ignored.
+		assert( foo.getValue!int(999) == 1 );
+
+		// No strings found
+		// If you'd prefer an exception, use `expectValue` instead.
+		assert( foo.getValue!string("Default") == "Default" );
+		assert( foo.getValue!string() is null );
+
+		// No floats found
+		assert( foo.getValue!float(99.9).approxEqual(99.9) );
+		assert( foo.getValue!float().isNaN() );
+	}
+
+	/++
+	Retrieve a value of type T from `this` tag. Throws if not found.
+	
+	Useful if you only expect one value of type T from this tag. Only looks
+	for values of `this` tag, it does not search child tags. If you wish to
+	search for a value in a child tag (for example, if this current tag is a
+	root tag), try `expectTagValue`.
+
+	If you want to get more than one value from this tag, use `values` instead.
+
+	If this tag has multiple values, the $(B $(I first)) value matching the
+	requested type will be returned. Ie, Extra values in the tag are ignored.
+	
+	An `sdlang.exception.ValueNotFoundException` will be thrown if no value of
+	the requested type can be found. If you'd rather receive a default value,
+	use `getValue` instead.
+	+/
+	T expectValue(T)() if(isValueType!T)
+	{
+		return getValueImpl!T(T.init, false);
+	}
+
+	///
+	@("Tag.expectValue")
+	unittest
+	{
+		import std.exception;
+		import std.math;
+		import sdlang.parser;
+		
+		auto root = parseSource(`
+			foo 1 true 2 false
+		`);
+		auto foo = root.getTag("foo");
+		assert( foo.expectValue!int() == 1 );
+		assert( foo.expectValue!bool() == true );
+
+		// No strings or floats found
+		// If you'd rather receive a default value than an exception, use `getValue` instead.
+		assertThrown!ValueNotFoundException( foo.expectValue!string() );
+		assertThrown!ValueNotFoundException( foo.expectValue!float() );
+	}
+
+	/++
+	Lookup a child tag by name, and retrieve a value of type T from it.
+	Returns a default value if not found.
+	
+	Useful if you only expect one value of type T from a given tag. Only looks
+	for immediate child tags of `this`, doesn't search recursively.
+
+	This is a shortcut for `getTag().getValue()`, except if the tag isn't found,
+	then instead of a null reference error, it will return the requested
+	`defaultValue` (or T.init by default).
+	+/
+	T getTagValue(T)(string fullTagName, T defaultValue = T.init) if(isValueType!T)
+	{
+		auto tag = getTag(fullTagName);
+		if(!tag)
+			return defaultValue;
+		
+		return tag.getValue!T(defaultValue);
+	}
+
+	///
+	@("Tag.getTagValue")
+	unittest
+	{
+		import std.exception;
+		import sdlang.parser;
+		
+		auto root = parseSource(`
+			foo 1 "a" 2 "b"
+			foo 3 "c" 4 "d"  // getTagValue considers this to override the first foo
+			
+			bar "hi"
+			bar 379  // getTagValue considers this to override the first bar
+		`);
+		assert( root.getTagValue!int("foo") == 3 );
+		assert( root.getTagValue!string("foo") == "c" );
+
+		// Value found, default value ignored.
+		assert( root.getTagValue!int("foo", 999) == 3 );
+
+		// Tag not found
+		// If you'd prefer an exception, use `expectTagValue` instead.
+		assert( root.getTagValue!int("doesnt-exist", 999) == 999 );
+		assert( root.getTagValue!int("doesnt-exist") == 0 );
+		
+		// The last "bar" tag doesn't have an int (only the first "bar" tag does)
+		assert( root.getTagValue!string("bar", "Default") == "Default" );
+		assert( root.getTagValue!string("bar") is null );
+
+		// Using namespaces:
+		root = parseSource(`
+			ns1:foo 1 "a" 2 "b"
+			ns1:foo 3 "c" 4 "d"
+			ns2:foo 11 "aa" 22 "bb"
+			ns2:foo 33 "cc" 44 "dd"
+			
+			ns1:bar "hi"
+			ns1:bar 379  // getTagValue considers this to override the first bar
+		`);
+		assert( root.getTagValue!int("ns1:foo") == 3  );
+		assert( root.getTagValue!int("*:foo"  ) == 33 ); // Search all namespaces
+
+		assert( root.getTagValue!string("ns1:foo") == "c"  );
+		assert( root.getTagValue!string("*:foo"  ) == "cc" ); // Search all namespaces
+		
+		// The last "bar" tag doesn't have a string (only the first "bar" tag does)
+		assert( root.getTagValue!string("*:bar", "Default") == "Default" );
+		assert( root.getTagValue!string("*:bar") is null );
+	}
+
+	/++
+	Lookup a child tag by name, and retrieve a value of type T from it.
+	Throws if not found,
+	
+	Useful if you only expect one value of type T from a given tag. Only
+	looks for immediate child tags of `this`, doesn't search recursively.
+	
+	This is a shortcut for `expectTag().expectValue()`.
+	+/
+	T expectTagValue(T)(string fullTagName) if(isValueType!T)
+	{
+		return expectTag(fullTagName).expectValue!T();
+	}
+
+	///
+	@("Tag.expectTagValue")
+	unittest
+	{
+		import std.exception;
+		import sdlang.parser;
+		
+		auto root = parseSource(`
+			foo 1 "a" 2 "b"
+			foo 3 "c" 4 "d"  // expectTagValue considers this to override the first foo
+			
+			bar "hi"
+			bar 379  // expectTagValue considers this to override the first bar
+		`);
+		assert( root.expectTagValue!int("foo") == 3 );
+		assert( root.expectTagValue!string("foo") == "c" );
+		
+		// The last "bar" tag doesn't have a string (only the first "bar" tag does)
+		// If you'd rather receive a default value than an exception, use `getTagValue` instead.
+		assertThrown!ValueNotFoundException( root.expectTagValue!string("bar") );
+
+		// Tag not found
+		assertThrown!TagNotFoundException( root.expectTagValue!int("doesnt-exist") );
+
+		// Using namespaces:
+		root = parseSource(`
+			ns1:foo 1 "a" 2 "b"
+			ns1:foo 3 "c" 4 "d"
+			ns2:foo 11 "aa" 22 "bb"
+			ns2:foo 33 "cc" 44 "dd"
+			
+			ns1:bar "hi"
+			ns1:bar 379  // expectTagValue considers this to override the first bar
+		`);
+		assert( root.expectTagValue!int("ns1:foo") == 3  );
+		assert( root.expectTagValue!int("*:foo"  ) == 33 ); // Search all namespaces
+
+		assert( root.expectTagValue!string("ns1:foo") == "c"  );
+		assert( root.expectTagValue!string("*:foo"  ) == "cc" ); // Search all namespaces
+		
+		// The last "bar" tag doesn't have a string (only the first "bar" tag does)
+		assertThrown!ValueNotFoundException( root.expectTagValue!string("*:bar") );
+		
+		// Namespace not found
+		assertThrown!TagNotFoundException( root.expectTagValue!int("doesnt-exist:bar") );
+	}
+
+	/++
+	Lookup an attribute of `this` tag by name, and retrieve a value of type T
+	from it. Returns a default value if not found.
+	
+	Useful if you only expect one attribute of the given name and type.
+	
+	Only looks for attributes of `this` tag, it does not search child tags.
+	If you wish to search for a value in a child tag (for example, if this
+	current tag is a root tag), try `getTagAttribute`.
+	
+	If you expect multiple attributes by the same name and want to get them all,
+	use `maybe`.`attributes[string]` instead.
+
+	The attribute name can optionally include a namespace, as in
+	`"namespace:name"`. Or, you can search all namespaces using `"*:name"`.
+	(Note that unlike tags. attributes can't be anonymous - that's what
+	values are.) Wildcard searching is only supported for namespaces, not names.
+	Use `maybe`.`attributes[0]` if you don't care about the name.
+
+	If this tag has multiple attributes, the $(B $(I first)) attribute
+	matching the requested name and type will be returned. Ie, Extra
+	attributes in the tag are ignored.
+	
+	You may provide a default value to be returned in case no attribute of
+	the requested name and type can be found. If you don't provide a default
+	value, `T.init` will be used.
+	
+	If you'd rather an exception be thrown when an attribute cannot be found,
+	use `expectAttribute` instead.
+	+/
+	T getAttribute(T)(string fullAttributeName, T defaultValue = T.init) if(isValueType!T)
+	{
+		auto parsedName = FullName.parse(fullAttributeName);
+		parsedName.ensureNoWildcardName(
+			"Instead, use 'Attribute.maybe.tags[0]', 'Attribute.maybe.all.tags[0]' or 'Attribute.maybe.namespace[ns].tags[0]'."
+		);
+		return getAttributeImpl!T(parsedName, defaultValue);
+	}
+	
+	///
+	@("Tag.getAttribute")
+	unittest
+	{
+		import std.exception;
+		import std.math;
+		import sdlang.parser;
+		
+		auto root = parseSource(`
+			foo z=0 X=1 X=true X=2 X=false
+		`);
+		auto foo = root.getTag("foo");
+		assert( foo.getAttribute!int("X") == 1 );
+		assert( foo.getAttribute!bool("X") == true );
+
+		// Value found, default value ignored.
+		assert( foo.getAttribute!int("X", 999) == 1 );
+
+		// Attribute name not found
+		// If you'd prefer an exception, use `expectValue` instead.
+		assert( foo.getAttribute!int("doesnt-exist", 999) == 999 );
+		assert( foo.getAttribute!int("doesnt-exist") == 0 );
+
+		// No strings found
+		assert( foo.getAttribute!string("X", "Default") == "Default" );
+		assert( foo.getAttribute!string("X") is null );
+
+		// No floats found
+		assert( foo.getAttribute!float("X", 99.9).approxEqual(99.9) );
+		assert( foo.getAttribute!float("X").isNaN() );
+
+		
+		// Using namespaces:
+		root = parseSource(`
+			foo  ns1:z=0  ns1:X=1  ns1:X=2  ns2:X=3  ns2:X=4
+		`);
+		foo = root.getTag("foo");
+		assert( foo.getAttribute!int("ns2:X") == 3 );
+		assert( foo.getAttribute!int("*:X") == 1 ); // Search all namespaces
+		
+		// Namespace not found
+		assert( foo.getAttribute!int("doesnt-exist:X", 999) == 999 );
+		
+		// No attribute X is in the default namespace
+		assert( foo.getAttribute!int("X", 999) == 999 );
+		
+		// Attribute name not found
+		assert( foo.getAttribute!int("ns1:doesnt-exist", 999) == 999 );
+	}
+	
+	/++
+	Lookup an attribute of `this` tag by name, and retrieve a value of type T
+	from it. Throws if not found.
+	
+	Useful if you only expect one attribute of the given name and type.
+	
+	Only looks for attributes of `this` tag, it does not search child tags.
+	If you wish to search for a value in a child tag (for example, if this
+	current tag is a root tag), try `expectTagAttribute`.
+
+	If you expect multiple attributes by the same name and want to get them all,
+	use `attributes[string]` instead.
+
+	The attribute name can optionally include a namespace, as in
+	`"namespace:name"`. Or, you can search all namespaces using `"*:name"`.
+	(Note that unlike tags. attributes can't be anonymous - that's what
+	values are.) Wildcard searching is only supported for namespaces, not names.
+	Use `attributes[0]` if you don't care about the name.
+
+	If this tag has multiple attributes, the $(B $(I first)) attribute
+	matching the requested name and type will be returned. Ie, Extra
+	attributes in the tag are ignored.
+	
+	An `sdlang.exception.AttributeNotFoundException` will be thrown if no
+	value of the requested type can be found. If you'd rather receive a
+	default value, use `getAttribute` instead.
+	+/
+	T expectAttribute(T)(string fullAttributeName) if(isValueType!T)
+	{
+		auto parsedName = FullName.parse(fullAttributeName);
+		parsedName.ensureNoWildcardName(
+			"Instead, use 'Attribute.tags[0]', 'Attribute.all.tags[0]' or 'Attribute.namespace[ns].tags[0]'."
+		);
+		return getAttributeImpl!T(parsedName, T.init, false);
+	}
+	
+	///
+	@("Tag.expectAttribute")
+	unittest
+	{
+		import std.exception;
+		import std.math;
+		import sdlang.parser;
+		
+		auto root = parseSource(`
+			foo z=0 X=1 X=true X=2 X=false
+		`);
+		auto foo = root.getTag("foo");
+		assert( foo.expectAttribute!int("X") == 1 );
+		assert( foo.expectAttribute!bool("X") == true );
+
+		// Attribute name not found
+		// If you'd rather receive a default value than an exception, use `getAttribute` instead.
+		assertThrown!AttributeNotFoundException( foo.expectAttribute!int("doesnt-exist") );
+
+		// No strings found
+		assertThrown!AttributeNotFoundException( foo.expectAttribute!string("X") );
+
+		// No floats found
+		assertThrown!AttributeNotFoundException( foo.expectAttribute!float("X") );
+
+		
+		// Using namespaces:
+		root = parseSource(`
+			foo  ns1:z=0  ns1:X=1  ns1:X=2  ns2:X=3  ns2:X=4
+		`);
+		foo = root.getTag("foo");
+		assert( foo.expectAttribute!int("ns2:X") == 3 );
+		assert( foo.expectAttribute!int("*:X") == 1 ); // Search all namespaces
+		
+		// Namespace not found
+		assertThrown!AttributeNotFoundException( foo.expectAttribute!int("doesnt-exist:X") );
+		
+		// No attribute X is in the default namespace
+		assertThrown!AttributeNotFoundException( foo.expectAttribute!int("X") );
+		
+		// Attribute name not found
+		assertThrown!AttributeNotFoundException( foo.expectAttribute!int("ns1:doesnt-exist") );
+	}
+
+	/++
+	Lookup a child tag and attribute by name, and retrieve a value of type T
+	from it. Returns a default value if not found.
+	
+	Useful if you only expect one attribute of type T from given
+	the tag and attribute names. Only looks for immediate child tags of
+	`this`, doesn't search recursively.
+
+	This is a shortcut for `getTag().getAttribute()`, except if the tag isn't
+	found, then instead of a null reference error, it will return the requested
+	`defaultValue` (or T.init by default).
+	+/
+	T getTagAttribute(T)(string fullTagName, string fullAttributeName, T defaultValue = T.init) if(isValueType!T)
+	{
+		auto tag = getTag(fullTagName);
+		if(!tag)
+			return defaultValue;
+		
+		return tag.getAttribute!T(fullAttributeName, defaultValue);
+	}
+	
+	///
+	@("Tag.getTagAttribute")
+	unittest
+	{
+		import std.exception;
+		import sdlang.parser;
+		
+		auto root = parseSource(`
+			foo X=1 X="a" X=2 X="b"
+			foo X=3 X="c" X=4 X="d"  // getTagAttribute considers this to override the first foo
+			
+			bar X="hi"
+			bar X=379  // getTagAttribute considers this to override the first bar
+		`);
+		assert( root.getTagAttribute!int("foo", "X") == 3 );
+		assert( root.getTagAttribute!string("foo", "X") == "c" );
+
+		// Value found, default value ignored.
+		assert( root.getTagAttribute!int("foo", "X", 999) == 3 );
+
+		// Tag not found
+		// If you'd prefer an exception, use `expectTagAttribute` instead of `getTagAttribute`
+		assert( root.getTagAttribute!int("doesnt-exist", "X", 999)   == 999 );
+		assert( root.getTagAttribute!int("doesnt-exist", "X")        == 0   );
+		assert( root.getTagAttribute!int("foo", "doesnt-exist", 999) == 999 );
+		assert( root.getTagAttribute!int("foo", "doesnt-exist")      == 0   );
+		
+		// The last "bar" tag doesn't have a string (only the first "bar" tag does)
+		assert( root.getTagAttribute!string("bar", "X", "Default") == "Default" );
+		assert( root.getTagAttribute!string("bar", "X") is null );
+		
+
+		// Using namespaces:
+		root = parseSource(`
+			ns1:foo X=1 X="a" X=2 X="b"
+			ns1:foo X=3 X="c" X=4 X="d"
+			ns2:foo X=11 X="aa" X=22 X="bb"
+			ns2:foo X=33 X="cc" X=44 X="dd"
+			
+			ns1:bar attrNS:X="hi"
+			ns1:bar attrNS:X=379  // getTagAttribute considers this to override the first bar
+		`);
+		assert( root.getTagAttribute!int("ns1:foo", "X") == 3  );
+		assert( root.getTagAttribute!int("*:foo",   "X") == 33 ); // Search all namespaces
+
+		assert( root.getTagAttribute!string("ns1:foo", "X") == "c"  );
+		assert( root.getTagAttribute!string("*:foo",   "X") == "cc" ); // Search all namespaces
+		
+		// bar's attribute X is't in the default namespace
+		assert( root.getTagAttribute!int("*:bar", "X", 999) == 999 );
+		assert( root.getTagAttribute!int("*:bar", "X") == 0 );
+
+		// The last "bar" tag's "attrNS:X" attribute doesn't have a string (only the first "bar" tag does)
+		assert( root.getTagAttribute!string("*:bar", "attrNS:X", "Default") == "Default" );
+		assert( root.getTagAttribute!string("*:bar", "attrNS:X") is null);
+	}
+
+	/++
+	Lookup a child tag and attribute by name, and retrieve a value of type T
+	from it. Throws if not found.
+	
+	Useful if you only expect one attribute of type T from given
+	the tag and attribute names. Only looks for immediate child tags of
+	`this`, doesn't search recursively.
+
+	This is a shortcut for `expectTag().expectAttribute()`.
+	+/
+	T expectTagAttribute(T)(string fullTagName, string fullAttributeName) if(isValueType!T)
+	{
+		return expectTag(fullTagName).expectAttribute!T(fullAttributeName);
+	}
+	
+	///
+	@("Tag.expectTagAttribute")
+	unittest
+	{
+		import std.exception;
+		import sdlang.parser;
+		
+		auto root = parseSource(`
+			foo X=1 X="a" X=2 X="b"
+			foo X=3 X="c" X=4 X="d"  // expectTagAttribute considers this to override the first foo
+			
+			bar X="hi"
+			bar X=379  // expectTagAttribute considers this to override the first bar
+		`);
+		assert( root.expectTagAttribute!int("foo", "X") == 3 );
+		assert( root.expectTagAttribute!string("foo", "X") == "c" );
+		
+		// The last "bar" tag doesn't have an int attribute named "X" (only the first "bar" tag does)
+		// If you'd rather receive a default value than an exception, use `getAttribute` instead.
+		assertThrown!AttributeNotFoundException( root.expectTagAttribute!string("bar", "X") );
+		
+		// Tag not found
+		assertThrown!TagNotFoundException( root.expectTagAttribute!int("doesnt-exist", "X") );
+
+		// Using namespaces:
+		root = parseSource(`
+			ns1:foo X=1 X="a" X=2 X="b"
+			ns1:foo X=3 X="c" X=4 X="d"
+			ns2:foo X=11 X="aa" X=22 X="bb"
+			ns2:foo X=33 X="cc" X=44 X="dd"
+			
+			ns1:bar attrNS:X="hi"
+			ns1:bar attrNS:X=379  // expectTagAttribute considers this to override the first bar
+		`);
+		assert( root.expectTagAttribute!int("ns1:foo", "X") == 3  );
+		assert( root.expectTagAttribute!int("*:foo",   "X") == 33 ); // Search all namespaces
+		
+		assert( root.expectTagAttribute!string("ns1:foo", "X") == "c"  );
+		assert( root.expectTagAttribute!string("*:foo",   "X") == "cc" ); // Search all namespaces
+		
+		// bar's attribute X is't in the default namespace
+		assertThrown!AttributeNotFoundException( root.expectTagAttribute!int("*:bar", "X") );
+
+		// The last "bar" tag's "attrNS:X" attribute doesn't have a string (only the first "bar" tag does)
+		assertThrown!AttributeNotFoundException( root.expectTagAttribute!string("*:bar", "attrNS:X") );
+
+		// Tag's namespace not found
+		assertThrown!TagNotFoundException( root.expectTagAttribute!int("doesnt-exist:bar", "attrNS:X") );
+	}
+
+	/++
+	Lookup a child tag by name, and retrieve all values from it.
+
+	This just like using `getTag()`.`values`, except if the tag isn't found,
+	it safely returns null (or an optional array of default values) instead of
+	a dereferencing null error.
+	
+	Note that, unlike `getValue`, this doesn't discriminate by the value's
+	type. It simply returns all values of a single tag as a `Value[]`.
+
+	If you'd prefer an exception thrown when the tag isn't found, use
+	`expectTag`.`values` instead.
+	+/
+	Value[] getTagValues(string fullTagName, Value[] defaultValues = null)
+	{
+		auto tag = getTag(fullTagName);
+		if(tag)
+			return tag.values;
+		else
+			return defaultValues;
+	}
+	
+	///
+	@("getTagValues")
+	unittest
+	{
+		import std.exception;
+		import sdlang.parser;
+		
+		auto root = parseSource(`
+			foo 1 "a" 2 "b"
+			foo 3 "c" 4 "d"  // getTagValues considers this to override the first foo
+		`);
+		assert( root.getTagValues("foo") == [Value(3), Value("c"), Value(4), Value("d")] );
+
+		// Tag not found
+		// If you'd prefer an exception, use `expectTag.values` instead.
+		assert( root.getTagValues("doesnt-exist") is null );
+		assert( root.getTagValues("doesnt-exist", [ Value(999), Value("Not found") ]) ==
+			[ Value(999), Value("Not found") ] );
+	}
+	
+	/++
+	Lookup a child tag by name, and retrieve all attributes in a chosen
+	(or default) namespace from it.
+
+	This just like using `getTag()`.`attributes` (or
+	`getTag()`.`namespace[...]`.`attributes`, or `getTag()`.`all`.`attributes`),
+	except if the tag isn't found, it safely returns an empty range instead
+	of a dereferencing null error.
+	
+	If provided, the `attributeNamespace` parameter can be either the name of
+	a namespace, or an empty string for the default namespace (the default),
+	or `"*"` to retreive attributes from all namespaces.
+	
+	Note that, unlike `getAttributes`, this doesn't discriminate by the
+	value's type. It simply returns the usual `attributes` range.
+
+	If you'd prefer an exception thrown when the tag isn't found, use
+	`expectTag`.`attributes` instead.
+	+/
+	auto getTagAttributes(string fullTagName, string attributeNamespace = null)
+	{
+		auto tag = getTag(fullTagName);
+		if(tag)
+		{
+			if(attributeNamespace && attributeNamespace in tag.namespaces)
+				return tag.namespaces[attributeNamespace].attributes;
+			else if(attributeNamespace == "*")
+				return tag.all.attributes;
+			else
+				return tag.attributes;
+		}
+
+		return AttributeRange(null, null, false);
+	}
+	
+	///
+	@("getTagAttributes")
+	unittest
+	{
+		import std.exception;
+		import sdlang.parser;
+		
+		auto root = parseSource(`
+			foo X=1 X=2
+			
+			// getTagAttributes considers this to override the first foo
+			foo X1=3 X2="c" namespace:bar=7 X3=4 X4="d"
+		`);
+
+		auto fooAttrs = root.getTagAttributes("foo");
+		assert( !fooAttrs.empty );
+		assert( fooAttrs.length == 4 );
+		assert( fooAttrs[0].name == "X1" && fooAttrs[0].value == Value(3)   );
+		assert( fooAttrs[1].name == "X2" && fooAttrs[1].value == Value("c") );
+		assert( fooAttrs[2].name == "X3" && fooAttrs[2].value == Value(4)   );
+		assert( fooAttrs[3].name == "X4" && fooAttrs[3].value == Value("d") );
+
+		fooAttrs = root.getTagAttributes("foo", "namespace");
+		assert( !fooAttrs.empty );
+		assert( fooAttrs.length == 1 );
+		assert( fooAttrs[0].name == "bar" && fooAttrs[0].value == Value(7) );
+
+		fooAttrs = root.getTagAttributes("foo", "*");
+		assert( !fooAttrs.empty );
+		assert( fooAttrs.length == 5 );
+		assert( fooAttrs[0].name == "X1"  && fooAttrs[0].value == Value(3)   );
+		assert( fooAttrs[1].name == "X2"  && fooAttrs[1].value == Value("c") );
+		assert( fooAttrs[2].name == "bar" && fooAttrs[2].value == Value(7)   );
+		assert( fooAttrs[3].name == "X3"  && fooAttrs[3].value == Value(4)   );
+		assert( fooAttrs[4].name == "X4"  && fooAttrs[4].value == Value("d") );
+
+		// Tag not found
+		// If you'd prefer an exception, use `expectTag.attributes` instead.
+		assert( root.getTagValues("doesnt-exist").empty );
+	}
+
+	@("*: Disallow wildcards for names")
+	unittest
+	{
+		import std.exception;
+		import std.math;
+		import sdlang.parser;
+		
+		auto root = parseSource(`
+			foo 1 X=2
+			ns:foo 3 ns:X=4
+		`);
+		auto foo = root.getTag("foo");
+		auto nsfoo = root.getTag("ns:foo");
+
+		// Sanity check
+		assert( foo !is null );
+		assert( foo.name == "foo" );
+		assert( foo.namespace == "" );
+
+		assert( nsfoo !is null );
+		assert( nsfoo.name == "foo" );
+		assert( nsfoo.namespace == "ns" );
+
+		assert( foo.getValue     !int() == 1 );
+		assert( foo.expectValue  !int() == 1 );
+		assert( nsfoo.getValue   !int() == 3 );
+		assert( nsfoo.expectValue!int() == 3 );
+
+		assert( root.getTagValue   !int("foo")    == 1 );
+		assert( root.expectTagValue!int("foo")    == 1 );
+		assert( root.getTagValue   !int("ns:foo") == 3 );
+		assert( root.expectTagValue!int("ns:foo") == 3 );
+
+		assert( foo.getAttribute     !int("X")    == 2 );
+		assert( foo.expectAttribute  !int("X")    == 2 );
+		assert( nsfoo.getAttribute   !int("ns:X") == 4 );
+		assert( nsfoo.expectAttribute!int("ns:X") == 4 );
+
+		assert( root.getTagAttribute   !int("foo", "X")       == 2 );
+		assert( root.expectTagAttribute!int("foo", "X")       == 2 );
+		assert( root.getTagAttribute   !int("ns:foo", "ns:X") == 4 );
+		assert( root.expectTagAttribute!int("ns:foo", "ns:X") == 4 );
+		
+		// No namespace
+		assertThrown!ArgumentException( root.getTag   ("*") );
+		assertThrown!ArgumentException( root.expectTag("*") );
+		
+		assertThrown!ArgumentException( root.getTagValue   !int("*") );
+		assertThrown!ArgumentException( root.expectTagValue!int("*") );
+
+		assertThrown!ArgumentException( foo.getAttribute       !int("*")        );
+		assertThrown!ArgumentException( foo.expectAttribute    !int("*")        );
+		assertThrown!ArgumentException( root.getTagAttribute   !int("*", "X")   );
+		assertThrown!ArgumentException( root.expectTagAttribute!int("*", "X")   );
+		assertThrown!ArgumentException( root.getTagAttribute   !int("foo", "*") );
+		assertThrown!ArgumentException( root.expectTagAttribute!int("foo", "*") );
+
+		// With namespace
+		assertThrown!ArgumentException( root.getTag   ("ns:*") );
+		assertThrown!ArgumentException( root.expectTag("ns:*") );
+		
+		assertThrown!ArgumentException( root.getTagValue   !int("ns:*") );
+		assertThrown!ArgumentException( root.expectTagValue!int("ns:*") );
+
+		assertThrown!ArgumentException( nsfoo.getAttribute     !int("ns:*")           );
+		assertThrown!ArgumentException( nsfoo.expectAttribute  !int("ns:*")           );
+		assertThrown!ArgumentException( root.getTagAttribute   !int("ns:*",   "ns:X") );
+		assertThrown!ArgumentException( root.expectTagAttribute!int("ns:*",   "ns:X") );
+		assertThrown!ArgumentException( root.getTagAttribute   !int("ns:foo", "ns:*") );
+		assertThrown!ArgumentException( root.expectTagAttribute!int("ns:foo", "ns:*") );
+
+		// With wildcard namespace
+		assertThrown!ArgumentException( root.getTag   ("*:*") );
+		assertThrown!ArgumentException( root.expectTag("*:*") );
+		
+		assertThrown!ArgumentException( root.getTagValue   !int("*:*") );
+		assertThrown!ArgumentException( root.expectTagValue!int("*:*") );
+
+		assertThrown!ArgumentException( nsfoo.getAttribute     !int("*:*")          );
+		assertThrown!ArgumentException( nsfoo.expectAttribute  !int("*:*")          );
+		assertThrown!ArgumentException( root.getTagAttribute   !int("*:*",   "*:X") );
+		assertThrown!ArgumentException( root.expectTagAttribute!int("*:*",   "*:X") );
+		assertThrown!ArgumentException( root.getTagAttribute   !int("*:foo", "*:*") );
+		assertThrown!ArgumentException( root.expectTagAttribute!int("*:foo", "*:*") );
+	}
+	
 	override bool opEquals(Object o)
 	{
 		auto t = cast(Tag)o;
@@ -981,9 +2075,10 @@ class Tag
 		return allTags == t.allTags;
 	}
 	
-	/// Treats 'this' as the root tag. Note that root tags cannot have
+	/// Treats `this` as the root tag. Note that root tags cannot have
 	/// values or attributes, and cannot be part of a namespace.
-	/// If this isn't a valid root tag, 'SDLangValidationException' will be thrown.
+	/// If this isn't a valid root tag, `sdlang.exception.ValidationException`
+	/// will be thrown.
 	string toSDLDocument()(string indent="\t", int indentLevel=0)
 	{
 		Appender!string sink;
@@ -996,21 +2091,21 @@ class Tag
 		if(isOutputRange!(Sink,char))
 	{
 		if(values.length > 0)
-			throw new SDLangValidationException("Root tags cannot have any values, only child tags.");
+			throw new ValidationException("Root tags cannot have any values, only child tags.");
 
 		if(allAttributes.length > 0)
-			throw new SDLangValidationException("Root tags cannot have any attributes, only child tags.");
+			throw new ValidationException("Root tags cannot have any attributes, only child tags.");
 
 		if(_namespace != "")
-			throw new SDLangValidationException("Root tags cannot have a namespace.");
+			throw new ValidationException("Root tags cannot have a namespace.");
 		
 		foreach(tag; allTags)
 			tag.toSDLString(sink, indent, indentLevel);
 	}
 	
-	/// Output this entire tag in SDL format. Does *not* treat 'this' as
+	/// Output this entire tag in SDL format. Does $(B $(I not)) treat `this` as
 	/// a root tag. If you intend this to be the root of a standard SDL
-	/// document, use 'toSDLDocument' instead.
+	/// document, use `toSDLDocument` instead.
 	string toSDLString()(string indent="\t", int indentLevel=0)
 	{
 		Appender!string sink;
@@ -1023,10 +2118,10 @@ class Tag
 		if(isOutputRange!(Sink,char))
 	{
 		if(_name == "" && values.length == 0)
-			throw new SDLangValidationException("Anonymous tags must have at least one value.");
+			throw new ValidationException("Anonymous tags must have at least one value.");
 		
 		if(_name == "" && _namespace != "")
-			throw new SDLangValidationException("Anonymous tags cannot have a namespace.");
+			throw new ValidationException("Anonymous tags cannot have a namespace.");
 	
 		// Indent
 		foreach(i; 0..indentLevel)
@@ -1080,7 +2175,7 @@ class Tag
 			sink.put("\n");
 	}
 
-	/// Not the most efficient, but it works.
+	/// Outputs full information on the tag.
 	string toDebugString()
 	{
 		import std.algorithm : sort;
@@ -1129,7 +2224,7 @@ class Tag
 	}
 }
 
-version(sdlangUnittest)
+version(unittest)
 {
 	private void testRandomAccessRange(R, E)(R range, E[] expected, bool function(E, E) equals=null)
 	{
@@ -1269,12 +2364,11 @@ version(sdlangUnittest)
 	}
 }
 
-version(sdlangUnittest)
+@("*: Test sdlang ast")
 unittest
 {
+	import std.exception;
 	import sdlang.parser;
-	writeln("Unittesting sdlang ast...");
-	stdout.flush();
 	
 	Tag root;
 	root = parseSource("");
@@ -1473,26 +2567,26 @@ unittest
 	testRandomAccessRange(root.all.tags["blue"],                   [blue3, blue5]);
 	testRandomAccessRange(root.all.tags["orange"],                 [orange]);
 
-	assertThrown!SDLangRangeException(root.tags["foobar"]);
-	assertThrown!SDLangRangeException(root.all.tags["foobar"]);
-	assertThrown!SDLangRangeException(root.attributes["foobar"]);
-	assertThrown!SDLangRangeException(root.all.attributes["foobar"]);
+	assertThrown!DOMRangeException(root.tags["foobar"]);
+	assertThrown!DOMRangeException(root.all.tags["foobar"]);
+	assertThrown!DOMRangeException(root.attributes["foobar"]);
+	assertThrown!DOMRangeException(root.all.attributes["foobar"]);
 	
 	// DMD Issue #12585 causes a segfault in these two tests when using 2.064 or 2.065,
 	// so work around it.
-	//assertThrown!SDLangRangeException(root.namespaces["foobar"].tags["foobar"]);
-	//assertThrown!SDLangRangeException(root.namespaces["foobar"].attributes["foobar"]);
+	//assertThrown!DOMRangeException(root.namespaces["foobar"].tags["foobar"]);
+	//assertThrown!DOMRangeException(root.namespaces["foobar"].attributes["foobar"]);
 	bool didCatch = false;
 	try
 		auto x = root.namespaces["foobar"].tags["foobar"];
-	catch(SDLangRangeException e)
+	catch(DOMRangeException e)
 		didCatch = true;
 	assert(didCatch);
 	
 	didCatch = false;
 	try
 		auto x = root.namespaces["foobar"].attributes["foobar"];
-	catch(SDLangRangeException e)
+	catch(DOMRangeException e)
 		didCatch = true;
 	assert(didCatch);
 
@@ -1799,16 +2893,33 @@ unittest
 	assert(""        !in people.namespaces);
 	assert("foobar"  !in people.namespaces);
 	testRandomAccessRange(people.all.attributes, cast(Attribute[])[]);
+	
+	// Test clone()
+	auto rootClone = root.clone();
+	assert(rootClone !is root);
+	assert(rootClone.parent is null);
+	assert(rootClone.name      == root.name);
+	assert(rootClone.namespace == root.namespace);
+	assert(rootClone.location  == root.location);
+	assert(rootClone.values    == root.values);
+	assert(rootClone.toSDLDocument() == root.toSDLDocument());
+
+	auto peopleClone = people.clone();
+	assert(peopleClone !is people);
+	assert(peopleClone.parent is null);
+	assert(peopleClone.name      == people.name);
+	assert(peopleClone.namespace == people.namespace);
+	assert(peopleClone.location  == people.location);
+	assert(peopleClone.values    == people.values);
+	assert(peopleClone.toSDLString() == people.toSDLString());
 }
 
 // Regression test, issue #11: https://github.com/Abscissa/SDLang-D/issues/11
-version(sdlangUnittest)
+@("*: Regression test issue #11")
 unittest
 {
 	import sdlang.parser;
-	writeln("ast: Regression test issue #11...");
-	stdout.flush();
-	
+
 	auto root = parseSource(
 `//
 a`);