C# XElement.HasElement方法代码示例

		public static UnifiedExpression CreateInnerCreator(
				UnifiedExpression prefix,
				XElement node) {
			Contract.Requires(node != null);
			Contract.Requires(node.Name() == "innerCreator");
			/*
			 * innerCreator  
			 * :   '.' 'new' (nonWildcardTypeArguments)? IDENTIFIER (typeArguments)? classCreatorRest 
			 */

			//コード例
			// X . new <T> Sample <E> (1,2){}

			var typeArguments = node.HasElement("typeArguments")
										? CreateTypeArguments(
												node.Element("typeArguments"))
										: null;
			var type = UnifiedType.Create(
					node.Element("IDENTIFIER").Value).WrapGeneric(typeArguments);
			var creatorRest =
					CreateClassCreatorRest(node.Element("classCreatorRest"));
			var typeParameters = node.HasElement("nonWildcardTypeArguments")
										? CreateNonWildcardTypeArguments(
												node.Element(
														"nonWildcardTypeArguments"))
										: null;
			var prop = UnifiedNew.Create(
					type, creatorRest.Item1, typeParameters, null,
					creatorRest.Item2);

			return UnifiedProperty.Create(".", prefix, prop);
		}

		public static UnifiedExpression CreateConditionalExpression(
				XElement node) {
			Contract.Requires(node != null);
			Contract.Requires(node.Name() == "conditionalExpression");
			/*
			 * conditionalExpression 
			 * :   conditionalOrExpression ('?' expression ':' conditionalExpression)?
			 */

			if (node.HasElement("expression")) {
				return UnifiedTernaryExpression.Create(
						CreateConditionalOrExpression(node.NthElement(0)),
						CreateExpression(node.NthElement(2)),
						CreateConditionalExpression(node.NthElement(4))
						);
			}
			return CreateConditionalOrExpression(node.FirstElement());
		}

		public static UnifiedNew CreateArrayCreator(XElement node) {
			Contract.Requires(node != null);
			Contract.Requires(node.Name() == "arrayCreator");
			/*
			 * arrayCreator 
			 * :   'new' createdName '[' ']' ('[' ']')* arrayInitializer
			 * |   'new' createdName '[' expression ']' ( '[' expression ']' )* ('[' ']')* 
			 */

			var type = CreateCreatedName(node.NthElement(1));

			if (node.HasElement("arrayInitializer")) {
				var initVal =
						CreateArrayInitializer(node.Element("arrayInitializer"));
				var dimension = node.ElementsByContent("[").Count();
				type = type.WrapArrayRepeatedly(dimension);
				return UnifiedNew.Create(type, null, null, initVal);
			}

			type = node.Elements("expression")
					.Aggregate(
							type, (current, exp) => current
															.WrapArray(
																	CreateExpression
																			(
																					exp)
																			.
																			ToArgument
																			()));
			{
				var dimension = node.ElementsByContent("[")
						.Where(e => e.NextElement().Value == "]")
						.Count();
				type = type.WrapArrayRepeatedly(dimension);
			}
			return UnifiedNew.Create(type);
		}

        public static UnifiedExpression CreateTryStatement(XElement node)
        {
            Contract.Requires(node != null);
            Contract.Requires(node.Name() == "tryStatement");
            /*
             * tryStatement
             *		: 'try' LT!* statementBlock LT!* (finallyClause | catchClause (LT!* finallyClause)?)
             */

            var body = CreateStatementBlock(node.Element("statementBlock"));
            var catches = node.HasElement("catchClause")
                                  ? CreateCatchClause(
                                          node.Element("catchClause")) : null;
            var finallyBody = node.HasElement("finallyClause")
                                      ? CreateFinallyClause(
                                              node.Element("finallyClause"))
                                      : null;

            return UnifiedTry.Create(body, catches, null, finallyBody);
        }

		public static UnifiedExpression CreateForstatement(XElement node) {
			Contract.Requires(node != null);
			Contract.Requires(node.Name() == "forstatement");
			/*
			 * forstatement 
			 * // enhanced for loop
			 *     'for' '(' variableModifiers type IDENTIFIER ':' expression ')' statement
			 * // normal for loop
			 * |   'for' '(' (forInit)? ';' (expression)? ';' (expressionList)? ')' statement 
			 */
			if (node.NthElement(2).Name() == "variableModifiers") {
				var annotationsAndModifiers =
						CreateVariableModifiers(
								node.Element("variableModifiers"));
				return UnifiedForeach.Create(
						UnifiedVariableDefinition.Create(
								annotationsAndModifiers.Item1,
								annotationsAndModifiers.Item2,
								CreateType(node.Element("type")),
								UnifiedVariableIdentifier.Create(
										node.Element("IDENTIFIER").Value)
								).ToVariableDefinitionList(),
						CreateExpression(node.Element("expression")),
						CreateStatement(node.Element("statement")).ToBlock()
						);
			}
			var forInit = node.HasElement("forInit")
								? CreateForInit(node.Element("forInit"))
								: null;
			var condition = node.HasElement("expression")
									? CreateExpression(
											node.Element("expression"))
									: null;
			var step = node.HasElement("expressionList")
					   // TODO tuple?
							? CreateExpressionList(
									node.Element("expressionList"))
									.ToTupleLiteral()
							: null;
			var body =
					UnifiedBlock.Create(
							CreateStatement(node.Element("statement")));

			return UnifiedFor.Create(forInit, condition, step, body);
		}

		public static IEnumerable<UnifiedExpression> CreateClassBodyDeclaration
				(
				XElement node) {
			Contract.Requires(node != null);
			Contract.Requires(node.Name() == "classBodyDeclaration");
			/*
			 * classBodyDeclaration 
			 * :   ';'
			 * |   ('static')? block
			 * |   memberDecl 
			 */
			if (node.HasElement("block")) {
				//case static initializer
				var modifier = node.HasContent("static")
									? UnifiedModifier.Create("static")
									: null;
				yield return UnifiedStaticInitializer.Create(
						CreateBlock(node.Element("block")), null,
						UnifiedSet<UnifiedModifier>.Create(modifier));
			}
			if (node.HasElement("memberDecl")) {
				yield return CreateMemberDecl(node.Element("memberDecl"));
			}
		}

		public static UnifiedVariableDefinition CreateVariableDeclarator
				(
				XElement node, UnifiedSet<UnifiedAnnotation> annotations,
				UnifiedSet<UnifiedModifier> modifiers, UnifiedType type) {
			Contract.Requires(node != null);
			Contract.Requires(node.Name() == "variableDeclarator");
			/*
			 * variableDeclarator 
			 * :   IDENTIFIER ('[' ']')* ('=' variableInitializer)? 
			 */
			var initializer = node.HasElement("variableInitializer")
									? CreateVariableInitializer(
											node.Element(
													"variableInitializer"))
									: null;
			var dimension = node.ElementsByContent("[").Count();
			type = type.WrapArrayRepeatedly(dimension);

			return UnifiedVariableDefinition.Create(
					annotations, modifiers, type,
					UnifiedVariableIdentifier.Create(node.FirstElement().Value),
					initializer
					);
		}

        public static UnifiedFor CreateForStatement(XElement node)
        {
            Contract.Requires(node != null);
            Contract.Requires(node.Name() == "forStatement");
            /*
             * forStatement
             *		: 'for' LT!* '(' (LT!* forStatementInitialiserPart)? LT!* ';' (LT!* expression)? LT!* ';' (LT!* expression)? LT!* ')' LT!* statement
             */

            var init = node.HasElement("forStatementInitialiserPart")
                               ? CreateForStatementInitialiserPart(
                                       node.Element(
                                               "forStatementInitialiserPart"))
                               : null;

            //expressionを区別できないので、セミコロンの位置から条件なのかステップなのかを判断
            var semicolons = node.Elements().Where(e => e.Value == ";");
            var first = semicolons.ElementAt(0).NextElement();
            var second = semicolons.ElementAt(1).NextElement();

            var cond = first.Name() == "expression"
                               ? CreateExpression(first) : null;
            var step = second.Name() == "expression"
                               ? CreateExpression(second) : null;
            var body =
                    UnifiedBlock.Create(
                            CreateStatement(node.Element("statement")));

            return UnifiedFor.Create(init, cond, step, body);
        }

        public static UnifiedExpression CreateForStatementInitialiserPart(
            XElement node)
        {
            Contract.Requires(node != null);
            Contract.Requires(node.Name() == "forStatementInitialiserPart");
            /*
             * forStatementInitialiserPart
             *		: expressionNoIn
             *		| 'var' LT!* variableDeclarationListNoIn
             */

            if (node.NthElement(0).Name() == "expressionNoIn") {
                return CreateExpressionNoIn(node.NthElement(0));
            }
            if (node.HasElement("variableDeclarationListNoIn")) {
                return
                        CreateVariableDeclarationListNoIn(
                                node.Element("variableDeclarationListNoIn"));
            }
            throw new InvalidOperationException();
        }

        public static UnifiedCase CreateDefaultClause(XElement node)
        {
            Contract.Requires(node != null);
            Contract.Requires(node.Name() == "defaultClause");
            /*
             * defaultClause
             *		: 'default' LT!* ':' LT!* statementList?
             */
            var body = node.HasElement("statementList")
                               ? CreateStatementList(
                                       node.Element("statementList")) : null;

            return UnifiedCase.Create(null, UnifiedBlock.Create(body));
        }

        public static UnifiedExpression CreateForInStatementInitialiserPart(
            XElement node)
        {
            Contract.Requires(node != null);
            Contract.Requires(node.Name() == "forInStatementInitialiserPart");
            /*
             * forInStatementInitialiserPart
             *		: leftHandSideExpression
             *		| 'var' LT!* variableDeclarationNoIn
             */

            //左辺がCall or Newになる場合のコードはまだ未確認
            if (node.NthElement(0).Name() == "leftHandSideExpression") {
                return CreateLeftHandSideExpression(node.NthElement(0));
            }

            if (node.HasElement("variableDeclarationNoIn")) {
                return CreateVariableDeclarationNoIn(
                        node.Element("variableDeclarationNoIn"))
                        .ToVariableDefinitionList();
            }
            throw new InvalidOperationException();
        }

        public static UnifiedExpression CreateContinueStatement(XElement node)
        {
            Contract.Requires(node != null);
            Contract.Requires(node.Name() == "continueStatement");
            /*
             * continueStatement
             *		: 'continue' Identifier? statementEnd
             */

            var identifier = node.HasElement("Identifier")
                                     ? UnifiedVariableIdentifier.Create(
                                             node.Element("Identifier").Value)
                                     : null;

            return UnifiedContinue.Create(identifier);
        }

 public static UnifiedExpression CreateConditionalExpressionNoIn(
     XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "conditionalExpressionNoIn");
     /*
      * conditionalExpressionNoIn
      *		: logicalORExpressionNoIn (LT!* '?' LT!* assignmentExpressionNoIn LT!* ':' LT!* assignmentExpressionNoIn)?
      */
     if (node.HasElement("assignmentExpressionNoIn")) {
         return UnifiedTernaryExpression.Create(
                 CreateLogicalORExpressionNoIn(
                         node.Element("logicalORExpressionNoIn")),
                 CreateAssignmentExpressionNoIn(
                         node.Element("assignmentExpressionNoIn")),
                 CreateAssignmentExpressionNoIn(
                         node.Elements("assignmentExpressionNoIn").
                                 ElementAt(1)));
     }
     return CreateLogicalORExpressionNoIn(node.NthElement(0));
 }

        public static UnifiedCase CreateCaseClause(XElement node)
        {
            Contract.Requires(node != null);
            Contract.Requires(node.Name() == "caseClause");
            /*
             * caseClause
             *		: 'case' LT!* expression LT!* ':' LT!* statementList?
             */
            var cond = CreateExpression(node.Element("expression"));
            var body = node.HasElement("statementList")
                               ? CreateStatementList(
                                       node.Element("statementList")) : null;

            return UnifiedCase.Create(cond, UnifiedBlock.Create(body));
        }

				CreateClassCreatorRest(XElement node) {
			Contract.Requires(node != null);
			Contract.Requires(node.Name() == "classCreatorRest");
			/*
			 * classCreatorRest 
			 * :   arguments (classBody)? 
			 */

			var body = node.HasElement("classBody")
							? CreateClassBody(node.Element("classBody"))
							: null;
			return
					new Tuple<UnifiedSet<UnifiedArgument>, UnifiedBlock>(
							CreateArguments(node.Element("arguments")), body);
		}