private ProblemCollection CheckForProblems(AttributeNode attribute)
        {
			if (SemanticRulesUtilities.HasAttribute<ServiceContractAttribute>(attribute))
			{
				// reset the hasUnmatchedMessageHandler flag for each new type
				hasUnmatchedMessageHandler = false;
				return base.Problems;
			}

			string action = SemanticRulesUtilities.GetAttributeValue<String>(attribute, "Action");
			if (SemanticRulesUtilities.HasAttribute<OperationContractAttribute>(attribute) &&
				!string.IsNullOrEmpty(action) &&
				 action.Equals("*", StringComparison.OrdinalIgnoreCase))
			{
				// check if we already inspected another operation with unmatched message handler
				if (hasUnmatchedMessageHandler)
				{
					Resolution resolution = base.GetResolution();
					Problem problem = new Problem(resolution, attribute.SourceContext);
					base.Problems.Add(problem);
					return base.Problems;
				}
				hasUnmatchedMessageHandler = true;
			}
            return base.Problems;
        }

 public virtual AttributeNode GetClosestMatch(AttributeNode/*!*/ nd1, AttributeList/*!*/ list1, AttributeList list2, int list1pos, ref int list2start,
   TrivialHashtable/*!*/ matchedNodes, out Differences closestDifferences, out int list2pos) {
   closestDifferences = null; list2pos = -1;
   if (list2 == null) return null;
   if (nd1 == null || list1 == null || matchedNodes == null ||  list1pos < 0 || list1pos >= list1.Count || list2start < 0 || list2start >= list2.Count) {
     Debug.Assert(false); return null;
   }
   AttributeNode closest = null;
   Differences winnerSoFar = null;
   for (int j = list2start, m = list2.Count; j < m; j++){
     AttributeNode nd2 = list2[j];
     if (list2start == j) list2start++;
     if (nd2 == null) continue;
     if (matchedNodes[nd2.UniqueKey] != null) continue;
     Differences diff = this.GetDifferences(nd1, nd2);
     if (diff == null){Debug.Assert(false); continue;}
     if (diff.Similarity <= 0.5){
       //Not a good enough match
       if (list2start == j+1) list2start--; //The next call to GetClosestMatch will start looking at list2start, so this node will be considered then
       continue; //ignore it for the rest of this call
     }
     if (winnerSoFar != null && winnerSoFar.Similarity >= diff.Similarity) continue;
     winnerSoFar = closestDifferences = diff;
     closest = nd2;
     list2pos = j;
     if (diff.NumberOfDifferences == 0) return closest; //Perfect match, no need to look for other matches
   }
   if (closest != null){
     //^ assert winnerSoFar != null;
     //closest is closer to nd1 than any other node in list2, but this is no good if some other node in list1 has a better claim on closest
     for (int i = list1pos+1, n = list1.Count; i < n; i++){
       AttributeNode nd1alt = list1[i];
       if (nd1alt == null) continue;
       if (matchedNodes[nd1alt.UniqueKey] != null) continue;
       Differences diff = this.GetDifferences(nd1alt, closest);
       if (diff == null){Debug.Assert(false); continue;}
       if (diff.Similarity <= winnerSoFar.Similarity) continue;
       //nd1alt has a better claim on closest. See if it wants closest.
       Differences diff2;
       int j, k = list2start;
       AttributeNode nd2alt = this.GetClosestMatch(nd1alt, list1, list2, i, ref k,  matchedNodes, out diff2, out j);
       if (nd2alt != closest){
         Debug.Assert(nd2alt != null && diff2 != null && diff2.Similarity >= diff.Similarity);
         continue; //nd1alt prefers nd2alt to closest, so closest is still available
       }
       //nd1alt wants closest, take it out of the running
       matchedNodes[closest.UniqueKey] = nd1alt;
       //Now that closest is out of the running, try again
       k = list2start;
       AttributeNode newClosest = this.GetClosestMatch(nd1, list1, list2, i, ref k, matchedNodes, out winnerSoFar, out list2pos);
       //put closest back in the running so that the next call to this routine will pick it up
       matchedNodes[closest.UniqueKey] = closest;
       closest = newClosest;
       break;
     }
   }
   closestDifferences = winnerSoFar;
   return closest;
 }

 public static bool IsFragment(AttributeNode attribute)
 {
     ArgumentUtility.CheckNotNull ("attribute", attribute);
       string fragmentFullName = typeof (FragmentAttribute).FullName;
       bool isFragment = attribute.Type.FullName == fragmentFullName;
       bool isFragmentChild = attribute.Type.BaseType.FullName == fragmentFullName;
       return isFragment || isFragmentChild;
 }

        public IHtmlSmartTag TryCreateSmartTag(ITextView textView, ITextBuffer textBuffer, ElementNode element, AttributeNode attribute, int caretPosition, HtmlPositionType positionType)
        {
            if (element.InnerRange == null || element.GetText(element.InnerRange).Trim().Length == 0)
                return null;

            string displayText = element.Children.Count == 0 ? "Remove HTML tag" : "Remove and keep children";

            return new HtmlRemoveParentSmartTag(textView, textBuffer, element, displayText);
        }

        public IHtmlSmartTag TryCreateSmartTag(ITextView textView, ITextBuffer textBuffer, ElementNode element, AttributeNode attribute, int caretPosition, HtmlPositionType positionType)
        {
            if (element.IsStyleBlock() || element.IsJavaScriptBlock())
            {
                return new HtmlMinifySmartTag(textView, textBuffer, element);
            }

            return null;
        }

        public IHtmlSmartTag TryCreateSmartTag(ITextView textView, ITextBuffer textBuffer, ElementNode element, AttributeNode attribute, int caretPosition, HtmlPositionType positionType)
        {
            if (element.Children.Count > 0)
            {
                return new HtmlRemoveParentSmartTag(textView, textBuffer, element);
            }

            return null;
        }

        public IHtmlSmartTag TryCreateSmartTag(ITextView textView, ITextBuffer textBuffer, ElementNode element, AttributeNode attribute, int caretPosition, HtmlPositionType positionType)
        {
            if (IsEnabled(element))
            {
                return new OptimizeImageSmartTag(textView, textBuffer, element);
            }

            return null;
        }

        public IHtmlSmartTag TryCreateSmartTag(ITextView textView, ITextBuffer textBuffer, ElementNode element, AttributeNode attribute, int caretPosition, HtmlPositionType positionType)
        {
            if ((element.IsStyleBlock() || element.IsJavaScriptBlock()) && element.InnerRange.Length > 5)
            {
                return new ExtractToFileSmartTag(textView, textBuffer, element);
            }

            return null;
        }

        public IHtmlSmartTag TryCreateSmartTag(ITextView textView, ITextBuffer textBuffer, ElementNode element, AttributeNode attribute, int caretPosition, HtmlPositionType positionType)
        {
            if (element.GetAttribute("ng-controller") != null)
            {
                return new HtmlAngularControllerSmartTag(textView, textBuffer, element);
            }

            return null;
        }

        public WhileLoopStatementNode(ExpressionNode conditionExpression, StatementNodeBase body, AttributeNode[] attributes)
            : base(body, attributes)
        {
            if (conditionExpression == null)
                throw new ArgumentNullException("conditionExpression", "The ConditionExpression is null!");

            ConditionExpression = conditionExpression;
            AddChildren(ConditionExpression);
        }

        public IHtmlSmartTag TryCreateSmartTag(ITextView textView, ITextBuffer textBuffer, ElementNode element, AttributeNode attribute, int caretPosition, HtmlPositionType positionType)
        {
            if (element.GetAttribute("class") == null)
            {
                return new $safeitemname$SmartTag(textView, textBuffer, element);
            }

            return null;
        }

        public WhileLoopStatementNode While(ExpressionNode condition, StatementNodeBase body, AttributeNode[] attributes)
        {
            if (condition == null)
                ThrowHelper.ThrowArgumentNullException(() => condition);

            if (attributes == null)
                ThrowHelper.ThrowArgumentNullException(() => attributes);

            return new WhileLoopStatementNode(condition, body, attributes);
        }

 public static Literal GetAttributeValue( AttributeNode attr, int index ) {
   Debug.Assert( attr != null && index >= 0 && index < attr.Expressions.Count );
   if (attr == null) return null;
   for (int i = 0, n = attr.Expressions.Count, c = 0; i < n; i++) {
     Literal lit = attr.Expressions[i] as Literal;
     if (lit != null) {
       if (c == index) return lit;
       c++;
     }
   }
   return null;
 }

        public static Uri NormalizeUrl(AttributeNode attribute)
        {
            string value = attribute.Value;

            if (value.StartsWith("//", StringComparison.Ordinal))
                value = "http:" + value;

            Uri url;
            Uri.TryCreate(value, UriKind.Absolute, out url);

            return url;
        }

 public static Literal GetNamedAttributeValue( AttributeNode attr, Identifier name ) {
   if( attr == null ) return null;
   ExpressionList exprs = attr.Expressions;
   if( exprs == null ) return null;
   for( int i = 0, n = exprs.Count; i < n; i++ ) {
     NamedArgument na = exprs[i] as NamedArgument;
     if( na == null ) continue;
     if( na.Name.UniqueIdKey == name.UniqueIdKey ) {
       return na.Value as Literal;
     }
   }
   return null;
 }

        public ForeachLoopStatementNode Foreach(string variable, TypeNameNode variableType, ExpressionNode expression, StatementNodeBase body, AttributeNode[] attributes)
        {
            if (string.IsNullOrWhiteSpace(variable))
                ThrowHelper.ThrowException("The 'variable' is blank!");
            if (expression == null)
                ThrowHelper.ThrowArgumentNullException(() => expression);
            if (body == null)
                ThrowHelper.ThrowArgumentNullException(() => body);
            if (attributes == null)
                ThrowHelper.ThrowArgumentNullException(() => attributes);

            return new ForeachLoopStatementNode(variable, variableType, expression, body, attributes);
        }

 internal void AddAttribute(string name, string value, string xmlns, string prefix)
 {
     if (this.closed)
     {
         throw new InvalidOperationException(System.Transactions.SR.GetString("CannotAddToClosedDocument"));
     }
     if (this.current == null)
     {
         throw new InvalidOperationException(System.Transactions.SR.GetString("OperationInvalidOnAnEmptyDocument"));
     }
     AttributeNode item = new AttributeNode(name, prefix, xmlns, value);
     this.current.attributes.Add(item);
 }

        public IHtmlSmartTag TryCreateSmartTag(ITextView textView, ITextBuffer textBuffer, ElementNode element, AttributeNode attribute, int caretPosition, HtmlPositionType positionType)
        {
            AttributeNode attr = element.GetAttribute("src") ?? element.GetAttribute("href");

            if (attr == null)
                return null;

            Uri url = NormalizeUrl(attr);

            if (url == null || (!attr.Value.StartsWith("//", StringComparison.Ordinal) && !attr.Value.Contains("://")))
                return null;

            return new RemoteDownloaderSmartTag(textView, textBuffer, element, attr);
        }

 internal void AddAttribute(string name, string value, string xmlns, string prefix)
 {
     if (this.closed)
     {
         throw new InvalidOperationException();
     }
     if (this.current == null)
     {
         throw new InvalidOperationException();
     }
     AttributeNode node = new AttributeNode(name, prefix, value, xmlns);
     this.VerifySize(node);
     this.CurrentElement.attributes.Add(node);
 }

        /// <summary>
        /// Evaluates the rule.
        /// </summary>
        /// <param name="type">The type.</param>
		/// <param name="attribute">The attribute.</param>
		/// <param name="binding">The binding.</param>
        public override void EvaluateRule(TypeNode type, 
            AttributeNode attribute, string binding)
        {
			// for further info on Sessions and bindings, 
			// read: http://msdn2.microsoft.com/en-us/library/ms730879.aspx
			if ((SemanticRulesUtilities.GetAttributeValue<SessionMode>(attribute, "SessionMode") == SessionMode.Required &&
					IsSessionlessBinding(binding)) ||
				(SemanticRulesUtilities.GetAttributeValue<SessionMode>(attribute, "SessionMode") == SessionMode.NotAllowed &&
					IsSessionfullBinding(binding)))
			{
				Resolution resolution = base.GetResolution(type.FullName, binding);
				Problem problem = new Problem(resolution);
				base.Problems.Add(problem);
			}
        }