/// <summary>
/// Parse the text of the given designer file into a series of property declarations and return them.
/// This uses simple line-by-line parsing, not a proper code parse, because Visual Studio does the same
/// thing, and a .designer file is only considered valid if Visual Studio can read it.
/// </summary>
/// <param name="compileContext">The context in which to report errors during the parse.</param>
/// <param name="designerText">The text of the designer file to parse.</param>
/// <returns>The results of reading and parsing the designer file.</returns>
public DesignerInfo ParseDesignerText(ICompileContext compileContext, string designerText)
{
_compileContext = compileContext;
_line = 0;
Verbose("Beginning parse of .designer file.");
string[] lines = _lineSplitter.Split(designerText);
Verbose("{0} lines of text found in .designer file.", lines.Length);
DesignerInfo designerInfo = new DesignerInfo();
ParsingState state = ParsingState.BeforeNamespace;
for (_line = 1; _line <= lines.Length; _line++)
{
string currentLine = lines[_line - 1];
// Skip blank lines and comment lines.
if (_isBlankOrComment.IsMatch(currentLine))
{
continue;
}
// We use a simple finite-state machine to perform the parsing. It transitions on declarations and curly braces.
switch (state)
{
case ParsingState.BeforeNamespace:
{
Match match;
if ((match = _isNamespaceDeclaration.Match(currentLine)).Success)
{
if (string.IsNullOrEmpty(match.Groups["curlybrace"].Value))
{
Error("There is a valid namespace declaration here, but the opening curly brace is not on the same line. Visual Studio is strict about curly-brace placement, and probably cannot read this .designer file.");
}
else
{
designerInfo.Namespace = match.Groups["namespace"].Value;
Verbose("Parsed a valid namespace declaration for namespace \"{0}\".", designerInfo.Namespace);
state = ParsingState.BeforeClass;
}
}
else
{
Error("There should be a valid namespace declaration here. Visual Studio probably cannot read this .designer file.");
}
}
break;
case ParsingState.BeforeClass:
{
Match match;
if ((match = _isClassDeclaration.Match(currentLine)).Success)
{
if (string.IsNullOrEmpty(match.Groups["curlybrace"].Value))
{
Error("There is a valid class declaration here, but the opening curly brace is not on the same line. Visual Studio is strict about curly-brace placement, and probably cannot read this .designer file.");
}
else
{
designerInfo.ClassName = match.Groups["classname"].Value;
Verbose("Parsed a valid class declaration for class \"{0}\".", designerInfo.ClassName);
state = ParsingState.InsideClass;
}
}
else
{
Error("There should be a valid partial class declaration here. Visual Studio probably cannot read this .designer file.");
}
}
break;
case ParsingState.InsideClass:
{
Match match;
if (_isClosedCurlyBrace.IsMatch(currentLine))
{
state = ParsingState.AfterClass;
Verbose("End of class.");
}
else if ((match = _isPropertyDeclaration.Match(currentLine)).Success)
{
DesignerPropertyDeclaration propertyDeclaration = new DesignerPropertyDeclaration
{
PropertyTypeName = match.Groups["typename"].Value,
Name = match.Groups["propertyname"].Value,
};
designerInfo.PropertyDeclarations.Add(propertyDeclaration);
Verbose("Found property declaration: {0} {1}", propertyDeclaration.PropertyTypeName, propertyDeclaration.Name);
}
else
{
Warning("There should be a protected property declaration here. Visual Studio may not be able to read this .designer file.");
}
}
break;
case ParsingState.AfterClass:
if (_isClosedCurlyBrace.IsMatch(currentLine))
{
state = ParsingState.AfterNamespace;
Verbose("End of namespace.");
}
else
{
Error("There should be a closing curly brace here. Visual Studio probably cannot read this .designer file.");
}
break;
case ParsingState.AfterNamespace:
Error("There should be no more content after the end of the namespace. Visual Studio probably cannot read this .designer file.");
break;
}
}
Verbose("Ended parse of .designer file.");
return(designerInfo);
}
/// <summary>
/// Compare a parsed markup file against a parsed designer file to determine if they match each other.
/// </summary>
/// <param name="compileContext">The context in which errors should be reported.</param>
/// <param name="filename">The filename to use for reporting errors.</param>
/// <param name="markupInfo">The markup file to compare.</param>
/// <param name="designerInfo">The designer file to compare.</param>
/// <returns>True if they match, false if they do not.</returns>
private static bool CompareMarkupInfoToDesignerInfo(ICompileContext compileContext, string filename, MarkupInfo markupInfo, DesignerInfo designerInfo)
{
compileContext.Verbose("Comparing markup controls to .designer file properties...");
compileContext.Verbose("Comparing classnames.");
// First, make sure the type names match; we *should* be talking about the same classes here.
if (markupInfo.ClassType == null)
{
compileContext.Error("{0}: Designer file exists, but markup file has no Inherits=\"...\" attribute.", filename);
return(false);
}
if (markupInfo.ClassType.FullName != designerInfo.FullTypeName)
{
compileContext.Error("{0}: Designer file and markup file specify different type names (\"{1}\" in the markup, and \"{2}\" in the designer file.",
filename, markupInfo.ClassType.FullName, designerInfo.FullTypeName);
return(false);
}
// Build lookup tables for the property declarations in the designer file and in the markup file.
// We'll use these to make searching for property matches that much faster, and to detect duplicates,
// and to ensure that we're talking about the same set of properties in both files.
compileContext.Verbose("Checking for duplicate control declarations.");
Dictionary <string, OutputControl> markupPropertiesByName = new Dictionary <string, OutputControl>();
Dictionary <string, DesignerPropertyDeclaration> designerProperiesByName = new Dictionary <string, DesignerPropertyDeclaration>();
List <string> duplicateMarkupProperties = new List <string>();
foreach (OutputControl outputControl in markupInfo.OutputControls)
{
if (string.IsNullOrEmpty(outputControl.Name))
{
continue;
}
if (markupPropertiesByName.ContainsKey(outputControl.Name))
{
duplicateMarkupProperties.Add(outputControl.Name);
}
else
{
markupPropertiesByName.Add(outputControl.Name, outputControl);
}
}
List <string> duplicateDesignerProperties = new List <string>();
foreach (DesignerPropertyDeclaration propertyDeclaration in designerInfo.PropertyDeclarations)
{
if (designerProperiesByName.ContainsKey(propertyDeclaration.Name))
{
duplicateDesignerProperties.Add(propertyDeclaration.Name);
}
else
{
designerProperiesByName.Add(propertyDeclaration.Name, propertyDeclaration);
}
}
// Check the lookup tables for duplicates. There shouldn't be any.
if (duplicateMarkupProperties.Count > 0)
{
compileContext.Error("{0}: Malformed markup error: Found multiple controls in the markup that have the same ID. Stopping verification now due to invalid markup file. Duplicate IDs: {1}",
filename, Join(duplicateMarkupProperties, ", "));
}
if (duplicateDesignerProperties.Count > 0)
{
compileContext.Error("{0}: Malformed designer error: Found multiple property declarations in the .designer file that have the same name. Stopping verification now due to invalid designer file. Duplicate names: {1}",
filename, Join(duplicateDesignerProperties, ", "));
}
if (duplicateMarkupProperties.Count > 0 || duplicateDesignerProperties.Count > 0)
{
return(false);
}
// Okay, now check to see if the markup or designer declare property names that the other doesn't have.
compileContext.Verbose("Checking for missing control declarations.");
Type contentControl = typeof(System.Web.UI.WebControls.Content);
List <string> missingDesignerProperties = markupInfo.OutputControls
.Where(p => !string.IsNullOrEmpty(p.Name) && p.ReflectedControl.ControlType != contentControl && !designerProperiesByName.ContainsKey(p.Name))
.Select(p => p.Name)
.ToList();
List <string> missingMarkupProperties = designerInfo.PropertyDeclarations
.Where(p => !string.IsNullOrEmpty(p.Name) && !markupPropertiesByName.ContainsKey(p.Name))
.Select(p => p.Name)
.ToList();
if (missingDesignerProperties.Count > 0)
{
compileContext.Error("{0}: Missing property error: Found controls declared in the markup that do not exist in the .designer file. Missing IDs: {1}",
filename, Join(missingDesignerProperties, ", "));
}
if (missingMarkupProperties.Count > 0)
{
compileContext.Error("{0}: Missing control error: Found property declarations in the .designer file that have no control declaration in the markup. Missing controls: {1}",
filename, Join(missingMarkupProperties, ", "));
}
// We've now established that both files refer to the same set of names. We now need to check
// to make sure they all refer to the same control types.
int numTypeMismatches = 0;
compileContext.Verbose("Checking for type mismatches.");
foreach (OutputControl outputControl in markupInfo.OutputControls)
{
if (string.IsNullOrEmpty(outputControl.Name) ||
outputControl.ReflectedControl.ControlType == contentControl ||
!designerProperiesByName.ContainsKey(outputControl.Name))
{
continue;
}
DesignerPropertyDeclaration designerPropertyDeclaration = designerProperiesByName[outputControl.Name];
if (designerPropertyDeclaration.PropertyTypeName != outputControl.ReflectedControl.ControlType.FullName)
{
compileContext.Error("{0}: Type mismatch: Control \"{1}\" has type {2} in the markup but type {3} in the .designer file.",
filename, outputControl.Name, outputControl.ReflectedControl.ControlType.FullName, designerPropertyDeclaration.PropertyTypeName);
numTypeMismatches++;
}
}
if (missingDesignerProperties.Count > 0 || missingMarkupProperties.Count > 0 || numTypeMismatches > 0)
{
return(false);
}
// One last very touchy check: All the properties exist in both files, and they have the same names and
// same types --- but are they in the right order? Visual Studio is very picky about the order, and if
// they don't match, the Visual Studio designer will break.
compileContext.Verbose("Checking for mis-ordered declarations.");
for (int m = 0, d = 0; m < markupInfo.OutputControls.Count;)
{
OutputControl outputControl = markupInfo.OutputControls[m++];
if (string.IsNullOrEmpty(outputControl.Name) ||
outputControl.ReflectedControl.ControlType == contentControl)
{
continue;
}
DesignerPropertyDeclaration designerPropertyDeclaration = designerInfo.PropertyDeclarations[d++];
if (designerPropertyDeclaration.Name != outputControl.Name ||
designerPropertyDeclaration.PropertyTypeName != outputControl.ReflectedControl.ControlType.FullName)
{
compileContext.Error("{0}: Ordering error: All of the same controls exist in both the markup and the .designer file, but they do not appear in the same order.", filename);
return(false);
}
}
compileContext.Verbose("{0}: Success!", filename);
return(true);
}