private IList GetMethodsInParents(TypeDeclaration typeDeclaration, IList pmList, bool implemented)
{
ClassType classType;
if (implemented)
classType = ClassType.Class;
else
classType = ClassType.Interface;
if (typeDeclaration.BaseTypes.Count > 0)
{
foreach (TypeReference parentType in typeDeclaration.BaseTypes)
{
string baseType = GetFullName(parentType);
if (CodeBase.Types.Contains(baseType))
{
TypeDeclaration parentTypeDeclaration = (TypeDeclaration) CodeBase.Types[baseType];
if (parentTypeDeclaration.Type == classType)
{
pmList = GetMethods(parentTypeDeclaration, pmList);
pmList = GetMethodsInParents(parentTypeDeclaration, pmList, implemented);
}
}
}
}
return pmList;
}
public override object TrackedVisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)
{
if (IsDerivedFrom(typeDeclaration, "Comparator"))
{
IList methods = AstUtil.GetChildrenWithType(typeDeclaration, typeof(MethodDeclaration));
MethodDeclaration equalsMethod = new MethodDeclaration("equals",
Modifiers.Public, AstUtil.GetTypeReference("bool", typeDeclaration), new List<ParameterDeclarationExpression>(), null);
equalsMethod.Parent = typeDeclaration;
TypeReference argTypeReference = AstUtil.GetTypeReference("java.lang.Object", equalsMethod);
argTypeReference.RankSpecifier = new int[] {};
equalsMethod.Parameters.Add(new ParameterDeclarationExpression(argTypeReference, "obj"));
if (Contains(methods, equalsMethod))
{
int index = IndexOf(methods, equalsMethod);
MethodDeclaration method = (MethodDeclaration) methods[index];
AstUtil.RemoveModifierFrom(method, Modifiers.Abstract);
method.TypeReference.Type = "bool";
CreateMethodImplementation(method);
}
else
{
CreateMethodImplementation(equalsMethod);
typeDeclaration.Children.Add(equalsMethod);
equalsMethod.Parent = typeDeclaration;
}
}
return base.TrackedVisitTypeDeclaration(typeDeclaration, data);
}
public override object TrackedVisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)
{
if (IsAbstractClass(typeDeclaration))
{
IList currentClassMethods = AstUtil.GetChildrenWithType(typeDeclaration, typeof(MethodDeclaration));
currentClassMethods = GetMethodsInParents(typeDeclaration, currentClassMethods, true);
IList methodsInParents = new ArrayList();
methodsInParents = GetMethodsInParents(typeDeclaration, methodsInParents, false);
methodsInParents = FilterImplementedMethods(methodsInParents);
IList abstractMethods = GetDiffList(currentClassMethods, methodsInParents);
if (abstractMethods.Count > 0)
{
TypeDeclaration replacedTypeDeclaration = typeDeclaration;
foreach (MethodDeclaration method in abstractMethods)
{
MethodDeclaration newMethod;
newMethod = new MethodDeclaration(method.Name,
Modifiers.Public | Modifiers.Abstract,
method.TypeReference,
method.Parameters,
method.Attributes);
newMethod.Parent = replacedTypeDeclaration;
replacedTypeDeclaration.Children.Add(newMethod);
}
ReplaceCurrentNode(replacedTypeDeclaration);
}
}
return base.TrackedVisitTypeDeclaration(typeDeclaration, data);
}
public static string GenerateText(TypeDeclaration type, OrderedPartCollection<AbstractDynamicCompilationExtension> extensions)
{
var unit = new CompilationUnit();
var namespaces = new HashSet<string>
{
typeof (SystemTime).Namespace,
typeof (AbstractViewGenerator).Namespace,
typeof (Enumerable).Namespace,
typeof (IEnumerable<>).Namespace,
typeof (IEnumerable).Namespace,
typeof (int).Namespace,
typeof (LinqOnDynamic).Namespace,
typeof(Field).Namespace,
};
foreach (var extension in extensions)
{
foreach (var ns in extension.Value.GetNamespacesToImport())
{
namespaces.Add(ns);
}
}
foreach (var ns in namespaces)
{
unit.AddChild(new Using(ns));
}
unit.AddChild(type);
var output = new CSharpOutputVisitor();
unit.AcceptVisitor(output, null);
return output.Text;
}
protected override bool VerifyMethodCondition(TypeDeclaration typeDeclaration, MethodDeclaration methodDeclaration)
{
IList methods = AstUtil.GetChildrenWithType(typeDeclaration, typeof(MethodDeclaration));
string name = methodDeclaration.Name.Substring(3);
if (Contains(methods, methodDeclaration))
{
IList innerTypes = AstUtil.GetChildrenWithType(typeDeclaration, typeof(TypeDeclaration));
foreach (TypeDeclaration innerType in innerTypes)
{
if (innerType.Name == name)
return true;
}
IList constructors = AstUtil.GetChildrenWithType(typeDeclaration, typeof(ConstructorDeclaration));
foreach (ConstructorDeclaration constructorDeclaration in constructors)
{
if (constructorDeclaration.Name == name)
return true;
}
foreach (MethodDeclaration method in methods)
{
if (method.Name == name || char.ToUpper(method.Name[0]) + method.Name.Substring(1) == name)
return true;
}
}
else
{
IList properties = AstUtil.GetChildrenWithType(typeDeclaration, typeof(PropertyDeclaration));
return Contains(properties, name);
}
return false;
}
public override object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)
{
currentClass = currentNamepace + "." + typeDeclaration.Name;
base.VisitTypeDeclaration(typeDeclaration, data);
currentClass = null;
return null;
}
void Check(TypeDeclaration td)
{
Assert.AreEqual("Lexer", td.Name);
Assert.AreEqual(2, td.Children.Count);
Assert.AreEqual(0, ((ConstructorDeclaration)td.Children[0]).Body.Children.Count);
Assert.AreEqual(0, ((MethodDeclaration)td.Children[1]).Body.Children.Count);
}
internal static string Generate(ParametrizedNode methodToCall, TypeDeclaration parentType,
string returnVariableName)
{
var template = new MethodCallStub(methodToCall, parentType, returnVariableName);
var text = template.TransformText();
return text;
}
public override object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)
{
Push();
object result = base.VisitTypeDeclaration(typeDeclaration, data);
Pop();
return result;
}
public override object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)
{
if (typeDeclaration.Type == ClassType.Class && typeDeclaration.Modifier.HasFlag(Modifiers.Abstract))
UnlockWith(typeDeclaration);
return base.VisitTypeDeclaration(typeDeclaration, data);
}
protected bool IsMethodInExternalTypes(TypeDeclaration typeDeclaration, MethodDeclaration methodDeclaration)
{
bool found = false;
foreach (TypeReference baseType in typeDeclaration.BaseTypes)
{
string fullName = GetFullName(baseType);
if (!found && CodeBase.Types.Contains(fullName))
{
TypeDeclaration baseTypeDeclaration = (TypeDeclaration) CodeBase.Types[fullName];
if (IsInExternalLibraries(fullName) || fullName.StartsWith("Helpers."))
{
IList methods = AstUtil.GetChildrenWithType(baseTypeDeclaration, typeof(MethodDeclaration));
if (ContainsMethod(methods, methodDeclaration))
found = true;
else
found = IsMethodInExternalTypes(baseTypeDeclaration, methodDeclaration);
}
else
found = IsMethodInExternalTypes(baseTypeDeclaration, methodDeclaration);
if (found)
break;
}
}
return found;
}
public TypeDeclaration CreateType(TypeDefinition typeDef)
{
TypeDeclaration astType = new TypeDeclaration(ConvertModifiers(typeDef), new List<AttributeSection>());
astType.Name = typeDef.Name;
if (typeDef.IsEnum) { // NB: Enum is value type
astType.Type = ClassType.Enum;
} else if (typeDef.IsValueType) {
astType.Type = ClassType.Struct;
} else if (typeDef.IsInterface) {
astType.Type = ClassType.Interface;
} else {
astType.Type = ClassType.Class;
}
// Nested types
foreach(TypeDefinition nestedTypeDef in typeDef.NestedTypes) {
astType.Children.Add(CreateType(nestedTypeDef));
}
// Base type
if (typeDef.BaseType != null && !typeDef.IsValueType && typeDef.BaseType.FullName != Constants.Object) {
astType.BaseTypes.Add(new Ast.TypeReference(typeDef.BaseType.FullName));
}
AddTypeMembers(astType, typeDef);
return astType;
}
public override object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)
{
if (typeDeclaration.Type == ClassType.Class || typeDeclaration.Type == ClassType.Struct)
Classes.Add(typeDeclaration.Name, typeDeclaration);
return base.VisitTypeDeclaration(typeDeclaration, data);
}
// create
public static TypeDeclaration add_Type(this NamespaceDeclaration namespaceDeclaration, IClass iClass)
{
// move to method IClass.typeDeclaration();
var typeName = iClass.Name;
var newType = namespaceDeclaration.type(typeName); // check if already exists and if it does return it
if (newType != null)
return newType;
const Modifiers modifiers = Modifiers.None | Modifiers.Public;
newType = new TypeDeclaration(modifiers, new List<AttributeSection>());
newType.Name = typeName;
foreach (var baseType in iClass.BaseTypes)
{
if (baseType.FullyQualifiedName != "System.Object") // no need to include this one
newType.BaseTypes.Add(new TypeReference(baseType.FullyQualifiedName));
}
namespaceDeclaration.AddChild(newType);
return newType;
//return namespaceDeclaration.add_Type(iClass.Name);
}
public override object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)
{
if(typeDeclaration.Type == ClassType.Interface)
UnlockWith(typeDeclaration);
return base.VisitTypeDeclaration(typeDeclaration, data);
}
public static PythonConstructorInfo GetConstructorInfo(TypeDeclaration type)
{
PythonConstructorInfo pythonConstructorInfo;
List<FieldDeclaration> fieldDeclarations = new List<FieldDeclaration>();
ConstructorDeclaration constructorDeclaration = null;
foreach (INode child in type.Children)
{
ConstructorDeclaration constructorDeclaration1 = child as ConstructorDeclaration;
FieldDeclaration fieldDeclaration = child as FieldDeclaration;
if (constructorDeclaration1 != null)
{
constructorDeclaration = constructorDeclaration1;
}
else if (fieldDeclaration != null)
{
fieldDeclarations.Add(fieldDeclaration);
}
}
if ((fieldDeclarations.Count > 0 ? false : constructorDeclaration == null))
{
pythonConstructorInfo = null;
}
else
{
pythonConstructorInfo = new PythonConstructorInfo(constructorDeclaration, fieldDeclarations);
}
return pythonConstructorInfo;
}
public override object VisitTypeDeclaration (TypeDeclaration node, object data)
{
if (CurrentType != null) {
Console.WriteLine ("Nested types are not supported");
//throw CreateException (node, "Nested types are not supported");
}
if (IsHiddenClass (node))
return null;
if ((node.Modifier & Modifiers.Partial) > 0) {
Console.WriteLine ("Partial classes are not supported: " + node);
//throw CreateException (node, "Partial classes are not supported");
}
CurrentType = new JsTypeInfo { Name = GenericsHelper.GetScriptName (node), ClassType = node.Type, Namespace = Namespace, Usings = new HashSet<string> (Usings) };
Usings = new HashSet<string> ();
CurrentType.IsStatic = node.Type == ClassType.Enum || HasModifier (node.Modifier, Modifiers.Static);
if (node.Type != ClassType.Interface)
node.AcceptChildren (this, null);
if (CachedCctor != null) {
if (!ProcessCctor ())
throw CreateException (node, "Static constructor may only contain primitive or array static field initializations");
CachedCctor = null;
}
CollectedTypes.Add (CurrentType);
CurrentType = null;
return null;
}
public override object TrackedVisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)
{
fields = AstUtil.GetChildrenWithType(typeDeclaration, typeof(FieldDeclaration));
base.TrackedVisitTypeDeclaration(typeDeclaration, data);
AddNotDeclaredAccessor(typeDeclaration);
return null;
}
public static API_ASMX_Proxy add_Property_To_Type_Constructor(this API_ASMX_Proxy asmxProxy, TypeDeclaration targetType, string propertyName, TypeDeclaration propertyType)
{
targetType.add_Property(propertyName,propertyType)
.add_Ctor()
.body()
.add_Assignment(propertyName, propertyType);
return asmxProxy;
}
public void VisitTypeDeclaration_NotWizardStepPage_DoesNothing()
{
var type = new TypeDeclaration(Modifiers.Public, new List<AttributeSection>()) {Name = "SomeRandomType"};
mocks.ReplayAll();
visitor.VisitTypeDeclaration(type, null);
mocks.VerifyAll();
}
private void TransformQueryToClass()
{
CSharpSafeName = "Index_"+ Regex.Replace(Name, @"[^\w\d]", "_");
var type = new TypeDeclaration(Modifiers.Public, new List<AttributeSection>())
{
BaseTypes =
{
new TypeReference("AbstractViewGenerator")
},
Name = CSharpSafeName,
Type = ClassType.Class
};
var ctor = new ConstructorDeclaration(CSharpSafeName,
Modifiers.Public,
new List<ParameterDeclarationExpression>(), null);
type.Children.Add(ctor);
ctor.Body = new BlockStatement();
// this.ViewText = "96E65595-1C9E-4BFB-A0E5-80BF2D6FC185"; // Will be replaced later
ctor.Body.AddChild(new ExpressionStatement(
new AssignmentExpression(
new MemberReferenceExpression(new ThisReferenceExpression(), "ViewText"),
AssignmentOperatorType.Assign,
new PrimitiveExpression(mapReduceTextToken, mapReduceTextToken))));
foreach (var map in indexDefinition.Maps)
{
HandleMapFunction(ctor, map);
}
HandleTransformResults(ctor);
HandleReduceDefintion(ctor);
AddAdditionalInformation(ctor);
CompiledQueryText = QueryParsingUtils.GenerateText(type, extensions);
var sb = new StringBuilder("@\"");
foreach (var map in indexDefinition.Maps)
{
sb.AppendLine(map.Replace("\"", "\"\""));
}
if (indexDefinition.Reduce != null)
{
sb.AppendLine(indexDefinition.Reduce.Replace("\"", "\"\"")).AppendLine();
}
if (indexDefinition.TransformResults != null)
{
sb.AppendLine(indexDefinition.TransformResults.Replace("\"", "\"\"")).AppendLine();
}
sb.Append("\"");
CompiledQueryText = CompiledQueryText.Replace("\"" + mapReduceTextToken + "\"",
sb.ToString());
}
public override object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)
{
if (typeDeclaration.Type == ClassType.Enum)
{
UnlockWith(typeDeclaration);
}
return(base.VisitTypeDeclaration(typeDeclaration, data));
}
private ConstructorDeclaration GetConstructor(ExpressionStatement expression, TypeDeclaration typeDeclaration)
{
ConstructorDeclaration constructorDeclaration;
constructorDeclaration = new ConstructorDeclaration(typeDeclaration.Name, Modifiers.Public, null, null);
constructorDeclaration.Body = new BlockStatement();
constructorDeclaration.Body.Children.Add(expression);
typeDeclaration.Children.Add(constructorDeclaration);
return constructorDeclaration;
}
public override object TrackedVisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)
{
if (AstUtil.ContainsModifier(typeDeclaration, Modifiers.Final))
{
AstUtil.ReplaceModifiers(typeDeclaration, Modifiers.Final, Modifiers.Sealed);
ReplaceCurrentNode(typeDeclaration);
}
return base.TrackedVisitTypeDeclaration(typeDeclaration, data);
}
public void VisitTypeDeclaration_AControllerNoChildren_PushesAndPops()
{
var type = new TypeDeclaration(Modifiers.Public | Modifiers.Partial, new List<AttributeSection>()) { Name = ControllerName };
visitor.VisitTypeDeclaration(type, null);
treeService.AssertWasCalled(s => s.PushNode(Arg<ControllerTreeNode>.Matches(n => n.Name == ControllerName)));
treeService.AssertWasCalled(s => s.PopNode());
}
public void VisitTypeDeclaration_AControllerNotPartial_DoesNothing()
{
TypeDeclaration type = new TypeDeclaration(Modifiers.Public, new List<AttributeSection>());
type.Name = "SomeRandomController";
_mocks.ReplayAll();
_visitor.VisitTypeDeclaration(type, null);
_mocks.VerifyAll();
}
public override object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)
{
if (typeDeclaration.Type == ClassType.Class && typeDeclaration.Modifier.HasFlag(Modifiers.Abstract))
{
UnlockWith(typeDeclaration);
}
return(base.VisitTypeDeclaration(typeDeclaration, data));
}
/// <summary>
/// Initializes a new instance of the <see cref="MethodCallStub"/> parameterized template with the specified
/// <paramref name="methodToCall"/> and <paramref name="parentType"/>.
/// </summary>
///
/// <param name="methodToCall">
/// The <see cref="ParametrizedNode"/> representing the method or constructor for which a call stub is to be
/// written.
/// </param>
///
/// <param name="parentType">
/// The <see cref="TypeDeclaration"/> that contains <paramref name="methodToCall"/>.
/// </param>
///
/// <param name="variableName">
/// The name of the variable to which the result of the method will be assigned, if appropriate.
/// </param>
public MethodCallStub (ParametrizedNode methodToCall, TypeDeclaration parentType, string variableName)
: base (methodToCall, parentType)
{
VariableName = variableName ?? "result";
InstanceOrClass = NeedsInstance ? DetermineInstanceVariableName(parentType) : parentType.Name;
Invocation = methodToCall is MethodDeclaration
? InstanceOrClass + "." + methodToCall.Name
: "new " + parentType.Name;
}
public void VisitTypeDeclaration_AWizardStepPageNotPartial_DoesNothing()
{
var type = new TypeDeclaration(Modifiers.Public, new List<AttributeSection>()) {Name = "SomeRandomWizardStepPage"};
type.BaseTypes.Add(new TypeReference("WizardStepPage"));
mocks.ReplayAll();
visitor.VisitTypeDeclaration(type, null);
mocks.VerifyAll();
}
public void VisitTypeDeclaration_NotViewComponent_DoesNothing()
{
TypeDeclaration type = new TypeDeclaration(Modifiers.Public, new List<AttributeSection>());
type.Name = "SomeRandomType";
_mocks.ReplayAll();
_visitor.VisitTypeDeclaration(type, null);
_mocks.VerifyAll();
}
public override object TrackedVisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)
{
stubMembers.AddRange(Members.Split(','));
if (Inherit == null)
return base.TrackedVisitTypeDeclaration(typeDeclaration, data);
typeDeclaration.Children.Clear();
typeDeclaration.BaseTypes.Clear();
typeDeclaration.BaseTypes.Add(new TypeReference(Inherit));
return null;
}
public override object TrackedVisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)
{
string parentType;
if (HasExcludedMethod(typeDeclaration, out parentType))
{
methods = (IList) ParentTypes[parentType];
return base.TrackedVisitTypeDeclaration(typeDeclaration, data);
}
return null;
}
public override object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)
{
if (typeDeclaration.Type == ClassType.Enum)
{
foreach (var child in typeDeclaration.Children)
{
FieldDeclaration variablef = child as FieldDeclaration;
foreach (var field in variablef.Fields)
{
if (!field.Initializer.IsNull)
{
UnlockWith(typeDeclaration);
}
}
}
}
return(base.VisitTypeDeclaration(typeDeclaration, data));
}
//DC
public void mapType(NRefactoryAST.TypeDeclaration typeDeclaration, IClass iClass)
{
TypeDeclarationToIClass.Add(typeDeclaration, iClass);
IClassToTypeDeclaration.Add(iClass, typeDeclaration);
}
internal void ExecuteIntroduceMethod(UnknownMethodResolveResult rr, Ast.Expression invocationExpr, ITextEditor editor, bool isNew, object result)
{
IClass targetClass = IsEqualClass(rr.CallingClass, rr.Target.GetUnderlyingClass()) ? rr.CallingClass
: rr.Target.GetUnderlyingClass();
CodeGenerator gen = targetClass.ProjectContent.Language.CodeGenerator;
IAmbience ambience = targetClass.ProjectContent.Language.GetAmbience();
ClassFinder finder = new ClassFinder(rr.CallingMember);
ModifierEnum modifiers = ModifierEnum.None;
bool isExtension = !targetClass.IsUserCode();
if (IsEqualClass(rr.CallingClass, targetClass))
{
if (rr.CallingMember != null)
{
modifiers |= (rr.CallingMember.Modifiers & ModifierEnum.Static);
}
}
else
{
if (isExtension)
{
if (isNew)
{
targetClass = rr.CallingClass;
}
else
{
targetClass = result as IClass;
}
}
// exclude in Unit Test mode
if (WorkbenchSingleton.Workbench != null)
{
editor = (FileService.OpenFile(targetClass.CompilationUnit.FileName) as ITextEditorProvider).TextEditor;
}
if (targetClass.ClassType != ClassType.Interface)
{
modifiers |= ModifierEnum.Public;
}
if (rr.IsStaticContext)
{
modifiers |= ModifierEnum.Static;
}
}
NRefactoryResolver resolver = Extensions.CreateResolverForContext(targetClass.ProjectContent.Language, editor);
IReturnType type = resolver.GetExpectedTypeFromContext(invocationExpr);
Ast.TypeReference typeRef = CodeGenerator.ConvertType(type, finder);
if (typeRef.IsNull)
{
if (invocationExpr.Parent is Ast.ExpressionStatement)
{
typeRef = new Ast.TypeReference("void", true);
}
else
{
typeRef = new Ast.TypeReference("object", true);
}
}
Ast.MethodDeclaration method = new Ast.MethodDeclaration {
Name = rr.CallName,
Modifier = CodeGenerator.ConvertModifier(modifiers, finder),
TypeReference = typeRef,
Parameters = CreateParameters(rr, finder, invocationExpr as Ast.InvocationExpression).ToList(),
};
if (targetClass.ClassType != ClassType.Interface)
{
method.Body = CodeGenerator.CreateNotImplementedBlock();
}
RefactoringDocumentAdapter documentWrapper = new RefactoringDocumentAdapter(editor.Document);
if (isExtension)
{
method.Parameters.Insert(0, new Ast.ParameterDeclarationExpression(CodeGenerator.ConvertType(rr.Target, finder), "thisInstance"));
method.IsExtensionMethod = true;
method.Modifier |= Ast.Modifiers.Static;
}
if (isNew)
{
Ast.TypeDeclaration newType = new Ast.TypeDeclaration(isExtension ? Ast.Modifiers.Static : Ast.Modifiers.None, null);
newType.Name = result as string;
newType.AddChild(method);
gen.InsertCodeAfter(targetClass, documentWrapper, newType);
}
else
{
if (IsEqualClass(rr.CallingClass, targetClass))
{
gen.InsertCodeAfter(rr.CallingMember, documentWrapper, method);
}
else
{
gen.InsertCodeAtEnd(targetClass.BodyRegion, documentWrapper, method);
}
}
if (targetClass.ClassType == ClassType.Interface)
{
return;
}
ParseInformation info = ParserService.ParseFile(targetClass.CompilationUnit.FileName);
if (info != null)
{
IMember newMember;
if (isNew)
{
targetClass = info.CompilationUnit.Classes.FirstOrDefault(c => c.DotNetName == c.Namespace + "." + (result as string));
}
else
{
targetClass = info.CompilationUnit.Classes.Flatten(c => c.InnerClasses).FirstOrDefault(c => c.DotNetName == targetClass.DotNetName);
}
if (targetClass == null)
{
return;
}
if (IsEqualClass(rr.CallingClass, targetClass))
{
newMember = targetClass.GetInnermostMember(editor.Caret.Line, editor.Caret.Column);
newMember = targetClass.AllMembers
.OrderBy(m => m.BodyRegion.BeginLine)
.ThenBy(m2 => m2.BodyRegion.BeginColumn)
.First(m3 => m3.BodyRegion.BeginLine > newMember.BodyRegion.BeginLine);
}
else
{
newMember = targetClass.Methods.Last();
}
IDocumentLine line = editor.Document.GetLine(newMember.BodyRegion.BeginLine + 2);
int indentLength = DocumentUtilitites.GetWhitespaceAfter(editor.Document, line.Offset).Length;
editor.Select(line.Offset + indentLength, "throw new NotImplementedException();".Length);
}
}
public override object VisitTypeDeclaration(AST.TypeDeclaration typeDeclaration, object data)
{
DomRegion region = GetRegion(typeDeclaration.StartLocation, typeDeclaration.EndLocation);
DomRegion bodyRegion = GetRegion(typeDeclaration.BodyStartLocation, typeDeclaration.EndLocation);
DefaultClass c = new DefaultClass(cu, TranslateClassType(typeDeclaration.Type), ConvertTypeModifier(typeDeclaration.Modifier), region, GetCurrentClass());
c.BodyRegion = bodyRegion;
ConvertAttributes(typeDeclaration, c);
c.Documentation = GetDocumentation(region.BeginLine, typeDeclaration.Attributes);
if (currentClass.Count > 0)
{
DefaultClass cur = GetCurrentClass();
cur.InnerClasses.Add(c);
c.FullyQualifiedName = cur.FullyQualifiedName + '.' + typeDeclaration.Name;
}
else
{
c.FullyQualifiedName = PrependCurrentNamespace(typeDeclaration.Name);
cu.Classes.Add(c);
}
c.UsingScope = currentNamespace;
currentClass.Push(c);
ConvertTemplates(typeDeclaration.Templates, c); // resolve constrains in context of the class
// templates must be converted before base types because base types may refer to generic types
if (c.ClassType != ClassType.Enum && typeDeclaration.BaseTypes != null)
{
foreach (AST.TypeReference type in typeDeclaration.BaseTypes)
{
IReturnType rt = CreateReturnType(type, null, TypeVisitor.ReturnTypeOptions.BaseTypeReference);
if (rt != null)
{
c.BaseTypes.Add(rt);
}
}
}
object ret = typeDeclaration.AcceptChildren(this, data);
currentClass.Pop();
if (c.ClassType == ClassType.Module)
{
foreach (DefaultField f in c.Fields)
{
f.Modifiers |= ModifierEnum.Static;
}
foreach (DefaultMethod m in c.Methods)
{
m.Modifiers |= ModifierEnum.Static;
}
foreach (DefaultProperty p in c.Properties)
{
p.Modifiers |= ModifierEnum.Static;
}
foreach (DefaultEvent e in c.Events)
{
e.Modifiers |= ModifierEnum.Static;
}
}
return(ret);
}
