private static bool IsValidInheritedType(string str, out string err, out CSharpClassNameValidationResult init)
{
if (string.IsNullOrWhiteSpace(str))
{
init = null;
err = "Missing inherited class specifier.";
return(false);
}
init = CSharpClassNameValidator.ValidateInitialization(str, true);
if (!init.Success)
{
err = init.ErrorDescription;
return(false);
}
if (CSharpKeywords.IsTypeAliasKeyword(init.BaseName))
{
err = string.Format("Cannot inherit from the built in type alias '{0}'.", init.BaseName);
init = null;
return(false);
}
err = null;
return(true);
}
private static bool IsValidTypeConstraint(string str, out string err,
out CSharpTypeConstraintValidationResult init)
{
if (string.IsNullOrWhiteSpace(str))
{
init = null;
err = "Missing type constraint specifier.";
return(false);
}
init = new CSharpTypeConstraintValidationResult();
if (str == "class")
{
init.ConstraintType = CSharpTypeConstraintType.Class;
err = null;
return(true);
}
if (str == "struct")
{
init.ConstraintType = CSharpTypeConstraintType.Struct;
err = null;
return(true);
}
if (Regex.IsMatch(str, @"^new\(\s*\)$"))
{
init.ConstraintType = CSharpTypeConstraintType.New;
err = null;
return(true);
}
init.TypeSignature = CSharpClassNameValidator.ValidateInitialization(str, true);
init.ConstraintType = CSharpTypeConstraintType.Type;
if (!init.TypeSignature.Success)
{
err = init.TypeSignature.ErrorDescription;
init = null;
return(false);
}
if (CSharpKeywords.IsTypeAliasKeyword(init.TypeSignature.BaseName))
{
err = string.Format("Cannot use the built in type alias '{0}' as a type constraint.",
init.TypeSignature.BaseName);
init = null;
return(false);
}
err = null;
return(true);
}
private static CSharpClassNameValidationResult _Validate(string input, ClassSigType signatureType,
bool allowBuiltinAliases, CSharpParsedTypeValidateTypeCallback validateTypeCallback, int index)
{
if (input == null)
{
throw new ArgumentNullException("input", "Class name/signature string cannot be null!");
}
if (string.IsNullOrWhiteSpace(input))
{
return(new CSharpClassNameValidationResult
{
Success = false,
ErrorDescription =
"Class name/signature cannot be whitespace.",
ErrorIndex = index,
});
}
string fullyQualifiedName = "";
var genericArgs = new GenericArray <CSharpClassNameValidationResult>();
var qualifications = new GenericArray <Qualification>()
{
new Qualification(new StringBuilder(), index)
};
string genericPart = "";
bool isGeneric = false;
int genericBrackets = 0;
foreach (var c in input)
{
//enter generic arguments
if (c == '<')
{
isGeneric = true;
genericBrackets++;
}
//check if we have gotten to the generic part of the type signature yet (if any)
if (!isGeneric)
{
if (c == '.')
{
//qualifier operator is not allowed anywhere in declaration signatures because
//they only consist of a raw type name and generic argument specifications
if (signatureType == ClassSigType.Declaration)
{
return(new CSharpClassNameValidationResult
{
Success = false,
ErrorDescription =
string.Format(
"'.' name qualifier operator is not valid in a class declaration/generic " +
"type placeholder name."),
ErrorIndex = index,
});
}
//detect a missing qualifier section that's terminated with a dot.
if (string.IsNullOrWhiteSpace(qualifications.Last().ToString()))
{
return(new CSharpClassNameValidationResult
{
Success = false,
ErrorDescription =
"\'..\' is an invalid use of the qualification operator.",
ErrorIndex = index,
});
}
qualifications.Add(new Qualification(new StringBuilder(), index + 1));
}
else
{
qualifications.Last().Builder.Append(c);
}
}
if (genericBrackets == 0 && !isGeneric)
{
//accumulate to our fully qualified name
fullyQualifiedName += c;
}
else if (genericBrackets == 0 && isGeneric)
{
//we have exited even pairs of brackets and are on the
//other side of the generic arguments at the end of the signature
//there should not be anything here
return(new CSharpClassNameValidationResult
{
Success = false,
ErrorDescription = "extra content found after generic argument list.",
ErrorIndex = index
});
}
else if (!(genericBrackets == 1 && c == '<'))
{
//passed the start of the first < in the signature by 1
if ((c == ',' || c == '>') && genericBrackets == 1)
{
//we have accumulated a type argument suitable for recursive decent
//validate it recursively
var validateGenericArgument = _Validate(genericPart.Trim(), signatureType, allowBuiltinAliases,
validateTypeCallback, index - genericPart.Length);
//return immediately on failure
if (!validateGenericArgument.Success)
{
return(validateGenericArgument);
}
//add the validated 'tree'
genericArgs.Add(validateGenericArgument);
//reset the accumulator
genericPart = "";
}
else
{
//accumulate until we hit a comma or the > character
genericPart += c;
}
}
if (c == '>')
{
//exit a generic type scope
genericBrackets--;
}
index++;
}
if (genericBrackets > 0)
{
//something is amiss with bracket matching
return(new CSharpClassNameValidationResult
{
Success = false,
ErrorDescription = "mismatched generic type brackets.",
ErrorIndex = index
});
}
//there may be only one qualification, in which case
//the base name is also the fully qualified name.
var baseName = qualifications.Last();
if (qualifications.Count > 1)
{
//uses qualified names, this is definitely an initialization signature
//because the qualifier '.' operator returns an error in declaration signatures
//above the recursive call to validate
foreach (var name in qualifications)
{
if (string.IsNullOrWhiteSpace(name.Builder.ToString()))
{
return(new CSharpClassNameValidationResult
{
Success = false,
ErrorDescription =
string.Format("qualified type name '{0}' is incomplete.",
fullyQualifiedName),
ErrorIndex = name.StartIndex
});
}
}
foreach (var name in qualifications)
{
//check for syntax errors in the qualified name pieces, they need to be valid ID's and not keywords
//IsValidIdentifier takes care of both these criteria
if (!CSharpIDValidator.IsValidIdentifier(name.Builder.ToString()))
{
//sound something funky
return(new CSharpClassNameValidationResult
{
Success = false,
ErrorDescription =
string.Format(
"'{0}' is not valid in the given qualified type name '{1}'.", name.Builder,
fullyQualifiedName),
ErrorIndex = name.StartIndex
});
}
}
}
else
{
var shortName = baseName.Builder.ToString();
//single type argument to a generic type
if (string.IsNullOrWhiteSpace(shortName))
{
return(new CSharpClassNameValidationResult
{
Success = false,
ErrorDescription = string.Format("missing generic {0} name.",
signatureType == ClassSigType.Initialization ? "type argument" : "placeholder type"),
ErrorIndex = baseName.StartIndex,
});
}
bool aliasInitialization = allowBuiltinAliases && CSharpKeywords.BuiltInTypeMap.ContainsKey(shortName) &&
signatureType == ClassSigType.Initialization;
if (!aliasInitialization &&
!CSharpIDValidator.IsValidIdentifier(baseName.Builder.ToString()))
{
return(new CSharpClassNameValidationResult
{
Success = false,
ErrorDescription =
string.Format("'{0}' is not an allowed CSharp identifier.",
baseName.Builder),
ErrorIndex = baseName.StartIndex
});
}
}
var baseNameString = baseName.Builder.ToString();
if (isGeneric && CSharpKeywords.IsTypeAliasKeyword(fullyQualifiedName))
{
return(new CSharpClassNameValidationResult
{
Success = false,
ErrorDescription =
string.Format("Built in type alias '{0}' is not a generic type.",
baseName.Builder),
ErrorIndex = baseName.StartIndex
});
}
//success
var classDescription = new CSharpClassNameValidationResult()
{
QualifiedName = fullyQualifiedName,
BaseName = baseNameString,
GenericArguments = genericArgs,
IsGeneric = isGeneric,
Success = true
};
if (isGeneric)
{
classDescription.FullSignature = fullyQualifiedName + "<" +
string.Join(", ",
classDescription.GenericArguments.Select(x => x.FullSignature)) +
">";
}
else
{
classDescription.FullSignature = fullyQualifiedName;
}
if (validateTypeCallback == null || signatureType != ClassSigType.Initialization)
{
return(classDescription);
}
var typeCheckResult = validateTypeCallback(classDescription);
if (typeCheckResult.IsValid)
{
return(classDescription);
}
classDescription.FullSignature = null;
classDescription.ErrorIndex = qualifications.First().StartIndex;
classDescription.ErrorDescription = typeCheckResult.ErrorMessage;
classDescription.Success = false;
return(classDescription);
}