public static string csharpCode(this IMethod iMethod)
{
var @namespace = iMethod.@namespace();
var typeName = iMethod.typeName();
var ambiance = new CSharpAmbience();
var csharpCode = ("\t\t{0}".line() +
"\t\t{{".line() +
"\t\t\tthrow new System.Exception(\"O2 Auto Generated Method\");".line() +
"\t\t}}".line())
.format(ambiance.Convert(iMethod));
if (typeName.valid())
csharpCode = ("\tclass {0}".line() +
"\t{{".line() +
"{1}".line() +
"\t}}".line())
.format(typeName, csharpCode);
if (@namespace.valid())
csharpCode = ("namespace {0}".line() +
"{{".line() +
"{1}".line() +
"}}".line())
.format(@namespace, csharpCode);
//if (@namespace.valid());
return csharpCode;
}
public static string fullName(this IProperty iProperty)
{
if (iProperty == null)
return "[null value]";
CSharpAmbience ambience = new CSharpAmbience();
ambience.ConversionFlags = ConversionFlags.StandardConversionFlags | ConversionFlags.UseFullyQualifiedMemberNames | ConversionFlags.UseFullyQualifiedTypeNames;
return ambience.Convert(iProperty);
}
public static string fullName(this IMethod iMethod)
{
if (iMethod == null)
return "[null value]";
CSharpAmbience ambience = new CSharpAmbience();
ambience.ConversionFlags = ConversionFlags.StandardConversionFlags | ConversionFlags.UseFullyQualifiedMemberNames;
return ambience.Convert(iMethod);
}
public void FixtureSetUp()
{
valueCollection = SharedProjectContentRegistryForTests.Instance.Mscorlib.GetClass("System.Collections.Generic.Dictionary.ValueCollection", 2);
Assert.AreEqual(2, valueCollection.TypeParameters.Count);
Assert.AreEqual(2, valueCollection.DeclaringType.TypeParameters.Count);
fullMemberNameAmbience = new CSharpAmbience();
fullMemberNameAmbience.ConversionFlags = ConversionFlags.StandardConversionFlags | ConversionFlags.UseFullyQualifiedMemberNames;
}
public void RoundMethodParameterConvertedToStringUsingAmbienceReturnsDoubleNumberString()
{
IAmbience ambience = new CSharpAmbience();
string text = ambience.Convert(GetFirstRoundMethodParameter());
Assert.AreEqual("double number", text);
}
static string GetText(ResolveResult result)
{
// ReSharper disable CanBeReplacedWithTryCastAndCheckForNull
if (result == null) {
return null;
}
if (result is MixedResolveResult)
return GetText(((MixedResolveResult)result).PrimaryResult);
IAmbience ambience = new CSharpAmbience();
ambience.ConversionFlags = ConversionFlags.StandardConversionFlags | ConversionFlags.ShowAccessibility;
if (result is MemberResolveResult)
{
return GetMemberText(ambience, ((MemberResolveResult)result).ResolvedMember);
}
if (result is LocalResolveResult)
{
var rr = (LocalResolveResult)result;
ambience.ConversionFlags = ConversionFlags.UseFullyQualifiedTypeNames
| ConversionFlags.ShowReturnType;
var b = new StringBuilder();
b.Append(rr.IsParameter ? "parameter " : "local variable ");
b.Append(ambience.Convert(rr.Field));
return b.ToString();
}
if (result is NamespaceResolveResult) {
return "namespace " + ((NamespaceResolveResult)result).Name;
}
if (result is TypeResolveResult) {
IClass c = ((TypeResolveResult)result).ResolvedClass;
if (c != null)
return GetMemberText(ambience, c);
return ambience.Convert(result.ResolvedType);
}
if (result is MethodGroupResolveResult) {
var mrr = result as MethodGroupResolveResult;
IMethod m = mrr.GetMethodIfSingleOverload();
if (m != null)
return GetMemberText(ambience, m);
return "Overload of " + ambience.Convert(mrr.ContainingType) + "." + mrr.Name;
}
return null;
// ReSharper restore CanBeReplacedWithTryCastAndCheckForNull
}
static string GetText(ResolveResult result)
{
if (result == null) {
return null;
}
if (result is MixedResolveResult)
return GetText(((MixedResolveResult)result).PrimaryResult);
IAmbience ambience = new CSharpAmbience();
ambience.ConversionFlags = ConversionFlags.StandardConversionFlags | ConversionFlags.ShowAccessibility;
if (result is MemberResolveResult) {
return GetMemberText(ambience, ((MemberResolveResult)result).ResolvedMember);
} else if (result is LocalResolveResult) {
LocalResolveResult rr = (LocalResolveResult)result;
ambience.ConversionFlags = ConversionFlags.UseFullyQualifiedTypeNames
| ConversionFlags.ShowReturnType;
StringBuilder b = new StringBuilder();
if (rr.IsParameter)
b.Append("parameter ");
else
b.Append("local variable ");
b.Append(ambience.Convert(rr.Field));
return b.ToString();
} else if (result is NamespaceResolveResult) {
return "namespace " + ((NamespaceResolveResult)result).Name;
} else if (result is TypeResolveResult) {
IClass c = ((TypeResolveResult)result).ResolvedClass;
if (c != null)
return GetMemberText(ambience, c);
else
return ambience.Convert(result.ResolvedType);
} else if (result is MethodGroupResolveResult) {
MethodGroupResolveResult mrr = result as MethodGroupResolveResult;
IMethod m = mrr.GetMethodIfSingleOverload();
if (m != null)
return GetMemberText(ambience, m);
else
return "Overload of " + ambience.Convert(mrr.ContainingType) + "." + mrr.Name;
} else {
return null;
}
}
/// <summary>
/// Generates the completion data. This method is called by the text editor control.
/// </summary>
public override ICompletionData[] GenerateCompletionData(string fileName, TextArea textArea, char charTyped)
{
List<ICompletionData> completionData = new List<ICompletionData>();
completionData.Add(new DelegateCompletionData("new " + resolveResult.ResolvedType.Name + "();", 2,
"delegate " + resolvedClass.FullyQualifiedName + "\n" + CodeCompletionData.GetDocumentation(resolvedClass.Documentation)));
completionData.Add(new DelegateCompletionData("delegate { };", 3,
"${res:CSharpBinding.InsertAnonymousMethod}"));
CSharpAmbience ambience = new CSharpAmbience();
ambience.ConversionFlags = ConversionFlags.ShowParameterNames;
IMethod invoke = resolvedClass.SearchMember("Invoke", LanguageProperties.CSharp) as IMethod;
if (invoke != null) {
StringBuilder builder = new StringBuilder("delegate(");
for (int i = 0; i < invoke.Parameters.Count; ++i) {
if (i > 0) {
builder.Append(", ");
}
builder.Append(ambience.Convert(invoke.Parameters[i]));
}
builder.Append(") { };");
completionData.Add(new DelegateCompletionData(builder.ToString(), 3,
"${res:CSharpBinding.InsertAnonymousMethodWithParameters}"));
IClass callingClass = resolveResult.CallingClass;
IClass eventReturnType = invoke.ReturnType.GetUnderlyingClass();
IClass[] eventParameters = new IClass[invoke.Parameters.Count];
for (int i = 0; i < eventParameters.Length; i++) {
eventParameters[i] = invoke.Parameters[i].ReturnType.GetUnderlyingClass();
if (eventParameters[i] == null) {
eventReturnType = null;
break;
}
}
if (callingClass != null && eventReturnType != null) {
bool inStatic = false;
if (resolveResult.CallingMember != null)
inStatic = resolveResult.CallingMember.IsStatic;
foreach (IMethod method in callingClass.DefaultReturnType.GetMethods()) {
if (inStatic && !method.IsStatic)
continue;
if (!method.IsAccessible(callingClass, true))
continue;
if (method.Parameters.Count != invoke.Parameters.Count)
continue;
// check return type compatibility:
IClass c2 = method.ReturnType.GetUnderlyingClass();
if (c2 == null || !c2.IsTypeInInheritanceTree(eventReturnType))
continue;
bool ok = true;
for (int i = 0; i < eventParameters.Length; i++) {
c2 = method.Parameters[i].ReturnType.GetUnderlyingClass();
if (c2 == null || !eventParameters[i].IsTypeInInheritanceTree(c2)) {
ok = false;
break;
}
}
if (ok) {
completionData.Add(new CodeCompletionData(method));
}
}
}
}
return completionData.ToArray();
}
public void ExitMethodReturnTypeConvertedToStringUsingAmbienceReturnsVoid()
{
IAmbience ambience = new CSharpAmbience();
List<IMethod> methods = GetExitMethods();
IReturnType returnType = methods[0].ReturnType;
string text = ambience.Convert(returnType);
Assert.AreEqual("void", text);
}
public void ExitMethodParameterConvertedToStringUsingAmbienceReturnsObjectCodeString()
{
IAmbience ambience = new CSharpAmbience();
string text = ambience.Convert(GetFirstExitMethodParameter());
Assert.AreEqual("object code", text);
}
/// <summary>
/// Generates the completion data. This method is called by the text editor control.
/// </summary>
public override ICompletionData[] GenerateCompletionData(string fileName, TextArea textArea, char charTyped)
{
List<ICompletionData> completionData = new List<ICompletionData>();
// delegate { }
completionData.Add(new DelegateCompletionData("delegate { };", 3,
"${res:CSharpBinding.InsertAnonymousMethod}"));
CSharpAmbience ambience = new CSharpAmbience();
// get eventHandler type name incl. type argument list
ambience.ConversionFlags = ConversionFlags.ShowParameterNames | ConversionFlags.ShowTypeParameterList | ConversionFlags.UseFullyQualifiedTypeNames;
string eventHandlerFullyQualifiedTypeName = ambience.Convert(resolvedReturnType);
ambience.ConversionFlags = ConversionFlags.ShowParameterNames | ConversionFlags.ShowTypeParameterList;
string eventHandlerTypeName = ambience.Convert(resolvedReturnType);
// retrieve Invoke method from resolvedReturnType instead of resolvedClass to get a method where
// type arguments are substituted.
IMethod invoke = resolvedReturnType.GetMethods().Find(delegate(IMethod m) { return m.Name == "Invoke"; });
StringBuilder parameterString = new StringBuilder();
if (invoke != null) {
// build the parameter string
for (int i = 0; i < invoke.Parameters.Count; ++i) {
if (i > 0) {
parameterString.Append(", ");
}
parameterString.Append(ambience.Convert(invoke.Parameters[i]));
}
// delegate(object sender, EventArgs e) { };
StringBuilder anonMethodWithParametersBuilder =
new StringBuilder("delegate(").Append(parameterString.ToString()).Append(") { };");
completionData.Add(new DelegateCompletionData(anonMethodWithParametersBuilder.ToString(), 3,
"${res:CSharpBinding.InsertAnonymousMethodWithParameters}"));
// new EventHandler(ClassName_EventName);
IClass callingClass = resolveResult.CallingClass;
bool inStatic = false;
if (resolveResult.CallingMember != null)
inStatic = resolveResult.CallingMember.IsStatic;
// ...build the new handler name...
string newHandlerName = BuildHandlerName();
if (newHandlerName == null) {
MemberResolveResult mrr = resolveResult as MemberResolveResult;
IEvent eventMember = (mrr != null ? mrr.ResolvedMember as IEvent : null);
newHandlerName =
((callingClass != null) ? callingClass.Name : "callingClass")
+ "_"
+ ((eventMember != null) ? eventMember.Name : "eventMember");
}
// ...build the completion text...
StringBuilder newHandlerTextBuilder = new StringBuilder("new ").Append(eventHandlerTypeName).Append("(");
newHandlerTextBuilder.Append(newHandlerName).Append(");");
// ...build the optional new method text...
StringBuilder newHandlerCodeBuilder = new StringBuilder();
newHandlerCodeBuilder.AppendLine().AppendLine();
if (inStatic)
newHandlerCodeBuilder.Append("static ");
newHandlerCodeBuilder.Append(ambience.Convert(invoke.ReturnType)).Append(" ").Append(newHandlerName);
newHandlerCodeBuilder.Append("(").Append(parameterString.ToString()).AppendLine(")");
newHandlerCodeBuilder.AppendLine("{");
newHandlerCodeBuilder.AppendLine("throw new NotImplementedException();");
newHandlerCodeBuilder.Append("}");
// ...and add it to the completionData.
completionData.Add(new NewEventHandlerCompletionData(
newHandlerTextBuilder.ToString(),
2+newHandlerName.Length,
newHandlerName.Length,
"new " + eventHandlerFullyQualifiedTypeName +
"(" + newHandlerName + StringParser.Parse(")\n${res:CSharpBinding.GenerateNewHandlerInstructions}\n")
+ CodeCompletionData.ConvertDocumentation(resolvedClass.Documentation),
resolveResult,
newHandlerCodeBuilder.ToString()
));
if (callingClass != null) {
foreach (IMethod method in callingClass.DefaultReturnType.GetMethods()) {
if (inStatic && !method.IsStatic)
continue;
if (!method.IsAccessible(callingClass, true))
continue;
if (method.Parameters.Count != invoke.Parameters.Count)
continue;
// check return type compatibility:
if (!MemberLookupHelper.ConversionExists(method.ReturnType, invoke.ReturnType))
continue;
bool ok = true;
for (int i = 0; i < invoke.Parameters.Count; i++) {
if (!MemberLookupHelper.ConversionExists(invoke.Parameters[i].ReturnType, method.Parameters[i].ReturnType)) {
ok = false;
break;
}
}
if (ok) {
completionData.Add(new CodeCompletionData(method));
}
}
}
}
return completionData.ToArray();
}
