public override void OnClassDefinition(ClassDefinition node) { IAccessibilityChecker saved = _checker; _checker = new AccessibilityChecker(node); base.OnClassDefinition(node); _checker = saved; }
override public void OnStructDefinition(StructDefinition node) { ClassDefinition cd = new ClassDefinition(node.LexicalInfo); cd.Name = node.Name; cd.Attributes = node.Attributes; cd.Modifiers = node.Modifiers; cd.Members = node.Members; cd.GenericParameters = node.GenericParameters; cd.BaseTypes = node.BaseTypes; cd.BaseTypes.Insert(0, CodeBuilder.CreateTypeReference(TypeSystemServices.ValueTypeType)); foreach (TypeMember member in cd.Members) { if (member.IsVisibilitySet) continue; switch (member.NodeType) { case NodeType.Field: member.Visibility = Context.Parameters.DefaultFieldVisibility; break; case NodeType.Property: member.Visibility = Context.Parameters.DefaultPropertyVisibility; break; case NodeType.Method: member.Visibility = Context.Parameters.DefaultMethodVisibility; break; } if (member.IsProtected) member.Visibility = TypeMemberModifiers.Public; } OnClassDefinition(cd); ReplaceCurrentNode(cd); }
public override void LeaveClassDefinition(ClassDefinition node) { MarkVisited(node); if(!_classDefinitionList.Contains(node.Name)) { _classDefinitionList.Add(node.Name, node); } foreach (TypeReference baseTypeRef in node.BaseTypes) { IType baseType = GetType(baseTypeRef); EnsureRelatedNodeWasVisited(node, baseType); if (baseType.IsInterface) { ResolveInterfaceMembers(node, baseTypeRef, baseType); } else { if (IsAbstract(baseType)) { ResolveAbstractMembers(node, baseTypeRef, baseType); } } } }
public override void Run() { foreach(Module module in CompileUnit.Modules) { module.Imports.Add(new Import(module.LexicalInfo, "Castle.MonoRail.Views.Brail")); module.Imports.Add(new Import(module.LexicalInfo, "Castle.MonoRail.Framework")); foreach(string name in options.NamespacesToImport) { module.Imports.Add(new Import(module.LexicalInfo, name)); } ClassDefinition macro = new ClassDefinition(); macro.Name = GetViewTypeName(module.FullName); macro.BaseTypes.Add(new SimpleTypeReference("Castle.MonoRail.Views.Brail.BrailBase")); AddConstructor(macro); ScriptDirectoryProperty(macro, module); ViewFileNameProperty(macro, module); AddRunMethod(macro, module); foreach(TypeMember member in module.Members) { macro.Members.Add(member); } module.Members.Clear(); module.Members.Add(macro); } }
void CheckBaseTypes(ClassDefinition node) { IType baseClass = null; foreach (TypeReference baseTypeRef in node.BaseTypes) { IType baseType = GetType(baseTypeRef); if (baseType.IsInterface) continue; if (null != baseClass) { Error( CompilerErrorFactory.ClassAlreadyHasBaseType(baseTypeRef, node.Name, baseClass.FullName) ); continue; } baseClass = baseType; if (baseClass.IsFinal && !TypeSystemServices.IsError(baseClass)) { Error( CompilerErrorFactory.CannotExtendFinalType( baseTypeRef, baseClass.FullName)); } } if (null == baseClass) node.BaseTypes.Insert(0, CodeBuilder.CreateTypeReference(TypeSystemServices.ObjectType) ); }
public override void Run() { foreach(var module in CompileUnit.Modules) { foreach(string name in options.NamespacesToImport) { module.Imports.Add(new Import(module.LexicalInfo, name)); } var macro = new ClassDefinition {Name = GetViewTypeName(module.FullName)}; macro.BaseTypes.Add(new SimpleTypeReference(options.BaseType)); AddConstructor(macro); ScriptDirectoryProperty(macro, module); AddRunMethod(macro, module); foreach(var member in module.Members) { macro.Members.Add(member); } module.Members.Clear(); module.Members.Add(macro); } }
/// <summary> /// Run this compiler step /// </summary> public override void Run() { if (Context.References.Contains(baseClass.Assembly) == false) Context.Parameters.References.Add(baseClass.Assembly); foreach (Module module in CompileUnit.Modules) { foreach (string ns in namespaces) { module.Imports.Add(new Import(module.LexicalInfo, ns)); } ClassDefinition definition = new ClassDefinition(); definition.Name = module.FullName; definition.BaseTypes.Add(new SimpleTypeReference(baseClass.FullName)); GenerateConstructors(definition); // This is called before the module.Globals is set to a new block so that derived classes may retrieve the // block from the module. ExtendBaseClass(module, definition); module.Globals = new Block(); module.Members.Add(definition); } }
protected void CheckPrivateMembersNeverUsed(ClassDefinition node) { foreach (TypeMember member in node.Members) { WarnIfPrivateMemberNeverUsed(member); } }
// create a constructor that delegate to the base class private void AddConstructor(ClassDefinition macro) { var ctor = new Constructor(macro.LexicalInfo); ctor.Parameters.Add( new ParameterDeclaration("viewEngine", new SimpleTypeReference("MvcContrib.BrailViewEngine.BooViewEngine"))); // TODO: Update Reference // ctor.Parameters.Add( // new ParameterDeclaration("output", // new SimpleTypeReference("System.IO.TextWriter"))); // ctor.Parameters.Add( // new ParameterDeclaration("context", // new SimpleTypeReference("Castle.MonoRail.Framework.IEngineContext"))); // // ctor.Parameters.Add( // new ParameterDeclaration("__controller", // new SimpleTypeReference("Castle.MonoRail.Framework.IController"))); // // ctor.Parameters.Add( // new ParameterDeclaration("__controllerContext", // new SimpleTypeReference("Castle.MonoRail.Framework.IControllerContext"))); var mie = new MethodInvocationExpression(new SuperLiteralExpression()); mie.Arguments.Add(AstUtil.CreateReferenceExpression("viewEngine")); // mie.Arguments.Add(AstUtil.CreateReferenceExpression("output")); // mie.Arguments.Add(AstUtil.CreateReferenceExpression("context")); // mie.Arguments.Add(AstUtil.CreateReferenceExpression("__controller")); // mie.Arguments.Add(AstUtil.CreateReferenceExpression("__controllerContext")); ctor.Body.Add(mie); macro.Members.Add(ctor); }
public override void Run() { var klass = new ClassDefinition { Name = "Foo" }; var baseType = new SimpleTypeReference("object"); klass.BaseTypes.Add(baseType); var method = new Method { Name = "Bar" }; method.Body.Add( new ReturnStatement( new IntegerLiteralExpression(42))); klass.Members.Add(method); var module = CompileUnit.Modules[0]; Assert.AreEqual(0, module.Members.Count); My<CodeReifier>.Instance.ReifyInto(module, klass); Assert.AreEqual(1, module.Members.Count); Assert.AreSame(klass, module.Members[0]); var klassEntity = (IType) klass.Entity; Assert.IsTrue(klassEntity.IsClass); Assert.AreSame(TypeSystemServices.ObjectType, klassEntity.BaseType); var methodEntity = (IMethod)method.Entity; Assert.AreEqual(method.Name, methodEntity.Name); Assert.AreSame(TypeSystemServices.IntType, methodEntity.ReturnType); }
public override bool EnterClassDefinition(ClassDefinition node) { if (WasVisited(node)) return false; _visited.Add(node); return true; }
public override void LeaveClassDefinition(ClassDefinition node) { LeaveTypeDefinition(node); if (!node.HasInstanceConstructor && !node.IsStatic) { node.Members.Add(AstUtil.CreateDefaultConstructor(node)); } }
public override void LeaveClassDefinition(ClassDefinition node) { CheckModifierCombination(node); CantBeMarkedPartialIfNested(node); if (node.IsStatic) node.Modifiers |= TypeMemberModifiers.Abstract | TypeMemberModifiers.Final; }
public override void OnClassDefinition(ClassDefinition node) { if (null == node.Entity) { node.Entity = new InternalClass(TypeSystemServices, node); } Visit(node.Members); }
protected void CheckMembers(ClassDefinition node) { foreach (TypeMember member in node.Members) { WarnIfPrivateMemberNeverUsed(member); WarnIfProtectedMemberInSealedClass(member); } }
public void Merge(ClassDefinition node) { if (null == node) throw new ArgumentNullException("node"); if (ReferenceEquals(this, node)) return; this.Attributes.Extend(node.Attributes); this.BaseTypes.Extend(node.BaseTypes); this.Members.Extend(node.Members); }
public override void OnClassDefinition(ClassDefinition node) { Visit(node.Members, NodeType.ClassDefinition); InternalCallableType type = node.Entity as InternalCallableType; if (null != type) { ImplementICallableCall(type, node); } }
public BooClassBuilder(string name) { if (name == null) throw new ArgumentNullException("name"); _internalTypeSystemProvider = My<InternalTypeSystemProvider>.Instance; _codeBuilder = My<BooCodeBuilder>.Instance; _cd = new ClassDefinition { Name = name, IsSynthetic = true }; EnsureEntityFor(_cd); }
public void ReifyIntoShouldFailWithAlreadyConnectedMember() { var module = new Module(); RunCompilerStepAfterExpressionResolutionOn(new CompileUnit(module), new ActionStep(() => { var klass = new ClassDefinition { Name = "Foo" }; module.Members.Add(klass); Exceptions.Expecting<ArgumentException>(() => CodeReifier().ReifyInto(module, klass)); })); }
public override void LeaveClassDefinition(ClassDefinition node) { CheckModifierCombination(node); CheckMemberName(node); if(node.IsStatic) { node.Modifiers |= TypeMemberModifiers.Abstract | TypeMemberModifiers.Final; } }
public void SimplifyBaseTypeName(ClassDefinition node) { if (node.BaseTypes.Count != 0) { var simpleTypeReference = node.BaseTypes[0] as SimpleTypeReference; if (simpleTypeReference != null && simpleTypeReference.Name == "UnityEngine.MonoBehaviour") { simpleTypeReference.Name = "MonoBehaviour"; } } }
public ClassDefinition CreateEmptyCallableDefinition(string name) { var cd = new ClassDefinition { IsSynthetic = true, Name = name, Modifiers = TypeMemberModifiers.Final }; cd.Entity = new InternalCallableType(My<InternalTypeSystemProvider>.Instance, cd); cd.BaseTypes.Add(CodeBuilder.CreateTypeReference(TypeSystemServices.MulticastDelegateType)); cd.BaseTypes.Add(CodeBuilder.CreateTypeReference(TypeSystemServices.ICallableType)); cd.Attributes.Add(CodeBuilder.CreateAttribute(typeof(CompilerGeneratedAttribute))); cd.Members.Add(CreateCallableConstructor()); cd.Members.Add(CreateCallMethod()); return cd; }
// get the directory name where this script reside and create a property // that return this value. // this is used to calculate relative paths when loading subviews. private void ScriptDirectoryProperty(ClassDefinition macro, Module module) { Property p = new Property("ScriptDirectory"); p.Modifiers = TypeMemberModifiers.Override; p.Getter = new Method("getScriptDirectory"); p.Getter.Body.Add( new ReturnStatement( new StringLiteralExpression( Path.GetDirectoryName(module.LexicalInfo.FileName)))); macro.Members.Add(p); }
public override void OnClassDefinition(ClassDefinition node) { // Visit type definition's members to resolve base types on nested types base.OnClassDefinition(node); // Resolve and check base types ResolveBaseTypes(new Boo.Lang.List(), node); CheckBaseTypes(node); if (node.IsFinal) return; if (((IType)node.Entity).IsFinal) node.Modifiers |= TypeMemberModifiers.Final; }
/// <summary> /// Allow a derived class to perform additional operations on the newly created type definition. /// </summary> protected override void ExtendBaseClass(Module module, ClassDefinition definition) { Method method = new Method(methodName); if (parameters != null) { foreach (ParameterDeclaration parameter in parameters) { method.Parameters.Add(parameter); } } method.Body = module.Globals; definition.Members.Add(method); ExtendBaseClass(definition); }
/// <summary> /// Extends the base class by placing the blocks of macros into methods on the base class /// of the same name. /// </summary> /// <example> /// MyMethod: /// PerformActions /// /// If an overridable method called MyMethod exists on <see cref="BaseClassCompilerStep.BaseClass"/>, then /// it is overridden as follows: /// <code> /// public override void MyMethod() { PerformActions(); } /// </code> /// </example> protected override void ExtendBaseClass(Module module, ClassDefinition definition) { List<MethodInfo> methodsThatAreOverridable = new List<MethodInfo>(); MethodInfo[] baseClassMethods = BaseClass.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.InvokeMethod); foreach (MethodInfo method in baseClassMethods) { if(method.DeclaringType==typeof(object)) continue; if (method.IsVirtual || method.IsAbstract) methodsThatAreOverridable.Add(method); } MethodSubstitutionTransformer mst = new MethodSubstitutionTransformer(methodsThatAreOverridable.ToArray(), definition); mst.Visit(module); foreach (Statement statement in module.Globals.Statements) { ExpressionStatement es = statement as ExpressionStatement; if (es != null) { BinaryExpression be = es.Expression as BinaryExpression; if (be != null) { if (be.Left.NodeType == NodeType.ReferenceExpression && be.Operator == BinaryOperatorType.Assign) { ReferenceExpression refExp = be.Left as ReferenceExpression; Field field = new Field(refExp.LexicalInfo); field.Name = refExp.Name; field.Initializer = be.Right; definition.Members.Add(field); } } } } if (transformers != null) { foreach (DepthFirstTransformer transformer in transformers) transformer.Visit(module); } }
public BooClassBuilder(BooCodeBuilder codeBuilder, string name) { if (null == codeBuilder) { throw new ArgumentNullException("codeBuilder"); } if (null == name) { throw new ArgumentNullException("name"); } _codeBuilder = codeBuilder; _cd = new ClassDefinition(); _cd.Name = name; _cd.Entity = new InternalClass(_codeBuilder.TypeSystemServices, _cd); _cd.IsSynthetic = true; }
void ImplementICallableCall(InternalCallableType type, ClassDefinition node) { Method call = (Method)node.Members["Call"]; Debug.Assert(null != call); Debug.Assert(call.Body.IsEmpty); CallableSignature signature = type.GetSignature(); int byRefCount = GetByRefParamCount(signature); if (byRefCount > 0) { ImplementByRefICallableCall(call, type, node, signature, byRefCount); } else { ImplementRegularICallableCall(call, type, node, signature); } }
private void tryMethod(Node targetNode) { var method = targetNode as Method; if (method == null) { return; } var processmethod = method.Clone() as Method; processmethod.Name = "process"; processmethod.Modifiers = TypeMemberModifiers.Public | TypeMemberModifiers.Override; processmethod.Parameters.Clear(); //processmethod.Parameters.Add(new ParameterDeclaration("context", new SimpleTypeReference("Comdiv.Framework.Quick.QWebContext"))); processmethod.ReturnType = new SimpleTypeReference("System.Object"); var name = method.Name; var cls = new ClassDefinition(); cls.Name = name; cls.Members.Add(processmethod); method.ParentNode.Replace(method, cls); tryClass(cls); }
public override bool EnterClassDefinition(ClassDefinition node) { if (!node.IsPartial) { return false; } if (_partials.Contains(node.FullName)) { _current = (ClassDefinition)_partials[node.FullName]; MergeImports(node, _current); RemoveCurrentNode(); return true; } else { _partials[node.FullName] = node; return false; } }
public void InitializeModuleClass(Boo.Lang.Compiler.Ast.ClassDefinition moduleClass) { _moduleClassNamespace = (INamespace)_typeSystemServices.GetMemberEntity(moduleClass); _moduleClass = moduleClass; }
public override void LeaveClassDefinition(AST.ClassDefinition node) { LeaveTypeDefinition(node); base.LeaveClassDefinition(node); }
public override bool EnterClassDefinition(AST.ClassDefinition node) { EnterTypeDefinition(node, ClassType.Class); return(base.EnterClassDefinition(node)); }
public object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data) { if (typeDeclaration.Templates.Count > 0) { AddError(typeDeclaration, "Generic type definitions are not supported."); } B.TypeDefinition oldType = currentType; B.TypeDefinition typeDef; switch (typeDeclaration.Type) { case ClassType.Class: typeDef = new B.ClassDefinition(GetLexicalInfo(typeDeclaration)); break; case ClassType.Interface: typeDef = new B.InterfaceDefinition(GetLexicalInfo(typeDeclaration)); break; case ClassType.Enum: typeDef = new B.EnumDefinition(GetLexicalInfo(typeDeclaration)); break; case ClassType.Struct: typeDef = new B.StructDefinition(GetLexicalInfo(typeDeclaration)); break; case ClassType.Module: typeDef = new B.ClassDefinition(GetLexicalInfo(typeDeclaration)); typeDeclaration.Modifier |= Modifiers.Static; break; default: AddError(typeDeclaration, "Unknown class type."); return(null); } if (currentType != null) { typeDef.Modifiers = ConvertModifier(typeDeclaration, B.TypeMemberModifiers.Private); } else { typeDef.Modifiers = ConvertModifier(typeDeclaration, B.TypeMemberModifiers.Internal); } typeDef.Name = typeDeclaration.Name; typeDef.EndSourceLocation = GetLocation(typeDeclaration.EndLocation); ConvertAttributes(typeDeclaration.Attributes, typeDef.Attributes); ConvertTypeReferences(typeDeclaration.BaseTypes, typeDef.BaseTypes); if (currentType != null) { currentType.Members.Add(typeDef); } else { module.Members.Add(typeDef); } currentType = typeDef; typeDeclaration.AcceptChildren(this, data); currentType = oldType; return(typeDef); }