public override AstNode Visit(DelegateDefinition node)
        {
            // Parse the generic signature.
            GenericSignature genericSign = node.GetGenericSignature();
            GenericPrototype genProto    = GenericPrototype.Empty;
            PseudoScope      protoScope  = null;

            if (genericSign != null)
            {
                // Visit the generic signature.
                genericSign.Accept(this);

                // Connect the generic prototype.
                genProto = genericSign.GetPrototype();

                // Create the placeholders scope.
                protoScope = new PseudoScope(currentScope, genProto);
                node.SetGenericScope(protoScope);
            }

            // Prevent redefinition.
            ScopeMember old = currentContainer.FindType(node.GetName(), GenericPrototype.Empty);

            if (old != null)
            {
                Error(node, "trying to redefine a delegate.");
            }

            // Create the structure
            MemberFlags flags = node.GetFlags();
            // TODO: Check the flags.
            Class building = new Class(node.GetName(), flags, currentContainer);

            building.SetGenericPrototype(genProto);
            building.Position = node.GetPosition();
            node.SetStructure(building);

            // Add into the current scope.
            if (currentContainer.IsNamespace())
            {
                Namespace space = (Namespace)currentContainer;
                space.AddType(building);
            }
            else if (currentContainer.IsStructure() || currentContainer.IsInterface() || currentContainer.IsClass())
            {
                Structure parent = (Structure)currentContainer;
                parent.AddType(building);
            }
            else
            {
                Error(node, "unexpected place for a delegate.");
            }

            // Register the compute binding delegate.
            if (building.GetFullName() == "Chela.Compute.ComputeBinding")
            {
                currentModule.RegisterComputeBindingDelegate(building);
            }

            return(node);
        }
        public override AstNode Visit(ClassDefinition node)
        {
            // Check the partial flag.
            bool isPartial = (node.GetFlags() & MemberFlags.ImplFlagMask) == MemberFlags.Partial;

            // Add the parent static flag.
            if (currentContainer.IsStatic())
            {
                MemberFlags oldInstance = node.GetFlags() & MemberFlags.InstanceMask;
                if (oldInstance == MemberFlags.Static || oldInstance == MemberFlags.Instanced)
                {
                    MemberFlags flags = node.GetFlags() & ~MemberFlags.InstanceMask;
                    node.SetFlags(flags | MemberFlags.Static);
                }
                else
                {
                    Error(node, "static class member cannot be {0}.", oldInstance.ToString().ToLower());
                }
            }

            // Static classes are automatically sealed.
            if ((node.GetFlags() & MemberFlags.InstanceMask) == MemberFlags.Static)
            {
                MemberFlags flags = node.GetFlags() & ~MemberFlags.InheritanceMask;
                node.SetFlags(flags | MemberFlags.Sealed);
            }

            // Parse the generic signature.
            GenericSignature genericSign = node.GetGenericSignature();
            GenericPrototype genProto    = GenericPrototype.Empty;
            PseudoScope      protoScope  = null;

            if (genericSign != null)
            {
                // Visit the generic signature.
                genericSign.Accept(this);

                // Connect the generic prototype.
                genProto = genericSign.GetPrototype();

                // Create the placeholders scope.
                protoScope = new PseudoScope(currentScope, genProto);
                node.SetGenericScope(protoScope);
            }

            // Prevent redefinition.
            ScopeMember old = currentContainer.FindType(node.GetName(), genProto);

            if (old != null && (!isPartial || !old.IsClass()))
            {
                Error(node, "trying to redefine a class.");
            }

            // Create the structure
            Class clazz = (Class)old;

            if (clazz != null)
            {
                if (!clazz.IsPartial())
                {
                    Error(node, "incompatible partial class definitions.");
                }
            }
            else
            {
                clazz          = new Class(node.GetName(), node.GetFlags(), currentContainer);
                clazz.Position = node.GetPosition();
                clazz.SetGenericPrototype(genProto);
            }
            node.SetStructure(clazz);

            // Use the prototype scope.
            if (protoScope != null)
            {
                PushScope(protoScope);
            }

            // Register type maps.
            string     fullName = clazz.GetFullName();
            IChelaType alias;

            if (typeMaps.TryGetValue(fullName, out alias))
            {
                currentModule.RegisterTypeMap(alias, clazz);
            }

            // Register type association.
            IChelaType assoc;

            if (assocClasses.TryGetValue(fullName, out assoc))
            {
                currentModule.RegisterAssociatedClass(assoc, clazz);
            }

            // Array base class is special.
            if (fullName == "Chela.Lang.Array")
            {
                currentModule.RegisterArrayClass(clazz);
            }
            else if (fullName == "Chela.Lang.Attribute")
            {
                currentModule.RegisterAttributeClass(clazz);
            }
            else if (fullName == "Chela.Lang.ValueType")
            {
                currentModule.RegisterValueTypeClass(clazz);
            }
            else if (fullName == "Chela.Lang.Enum")
            {
                currentModule.RegisterEnumClass(clazz);
            }
            else if (fullName == "Chela.Lang.Type")
            {
                currentModule.RegisterTypeClass(clazz);
            }
            else if (fullName == "Chela.Lang.Delegate")
            {
                currentModule.RegisterDelegateClass(clazz);
            }
            else if (fullName == "Chela.Compute.StreamHolder")
            {
                currentModule.RegisterStreamHolderClass(clazz);
            }
            else if (fullName == "Chela.Compute.StreamHolder1D")
            {
                currentModule.RegisterStreamHolder1DClass(clazz);
            }
            else if (fullName == "Chela.Compute.StreamHolder2D")
            {
                currentModule.RegisterStreamHolder2DClass(clazz);
            }
            else if (fullName == "Chela.Compute.StreamHolder3D")
            {
                currentModule.RegisterStreamHolder3DClass(clazz);
            }
            else if (fullName == "Chela.Compute.UniformHolder")
            {
                currentModule.RegisterUniformHolderClass(clazz);
            }

            // Add into the current scope.
            if (currentContainer.IsNamespace())
            {
                Namespace space = (Namespace)currentContainer;
                if (old == null)
                {
                    space.AddType(clazz);
                }
            }
            else if (currentContainer.IsStructure() || currentContainer.IsInterface() || currentContainer.IsClass())
            {
                Structure parent = (Structure)currentContainer;
                if (old == null)
                {
                    parent.AddType(clazz);
                }
            }
            else
            {
                Error(node, "unexpected place for a class.");
            }

            // Push the class unsafe.
            if (clazz.IsUnsafe())
            {
                PushUnsafe();
            }

            // Update the scope.
            PushScope(clazz);

            // Visit the building children.
            VisitList(node.GetChildren());

            // Restore the scope.
            PopScope();

            // Restore the scope.
            if (protoScope != null)
            {
                PopScope();
            }

            // Pop the class unsafe.
            if (clazz.IsUnsafe())
            {
                PopUnsafe();
            }

            return(node);
        }
        public override AstNode Visit(InterfaceDefinition node)
        {
            // Parse the generic signature.
            GenericSignature genericSign = node.GetGenericSignature();
            GenericPrototype genProto    = GenericPrototype.Empty;
            PseudoScope      protoScope  = null;

            if (genericSign != null)
            {
                // Visit the generic signature.
                genericSign.Accept(this);

                // Connect the generic prototype.
                genProto = genericSign.GetPrototype();

                // Create the placeholders scope.
                protoScope = new PseudoScope(currentScope, genProto);
                node.SetGenericScope(protoScope);
            }

            // Prevent redefinition.
            ScopeMember old = currentContainer.FindType(node.GetName(), genProto);

            if (old != null)
            {
                Error(node, "trying to redefine a class.");
            }

            // Create the structure
            Interface iface = new Interface(node.GetName(), node.GetFlags(), currentContainer);

            iface.SetGenericPrototype(genProto);
            node.SetStructure(iface);
            iface.Position = node.GetPosition();

            // Register type maps.
            string     fullName = iface.GetFullName();
            IChelaType alias;

            if (typeMaps.TryGetValue(fullName, out alias))
            {
                currentModule.RegisterTypeMap(alias, ReferenceType.Create(iface));
            }

            // Register some important interfaces.
            if (fullName == "Chela.Lang.NumberConstraint")
            {
                currentModule.RegisterNumberConstraint(iface);
            }
            else if (fullName == "Chela.Lang.IntegerConstraint")
            {
                currentModule.RegisterIntegerConstraint(iface);
            }
            else if (fullName == "Chela.Lang.FloatingPointConstraint")
            {
                currentModule.RegisterFloatingPointConstraint(iface);
            }
            else if (fullName == "Chela.Collections.IEnumerable")
            {
                currentModule.RegisterEnumerableIface(iface);
            }
            else if (fullName == "Chela.Collections.IEnumerator")
            {
                currentModule.RegisterEnumeratorIface(iface);
            }
            else if (fullName.StartsWith("Chela.Collections.Generic.IEnumerable<"))
            {
                currentModule.RegisterEnumerableGIface(iface);
            }
            else if (fullName.StartsWith("Chela.Collections.Generic.IEnumerator<"))
            {
                currentModule.RegisterEnumeratorGIface(iface);
            }

            // Use the prototype scope.
            if (protoScope != null)
            {
                PushScope(protoScope);
            }

            // Add into the current scope.
            if (currentContainer.IsNamespace())
            {
                Namespace space = (Namespace)currentContainer;
                space.AddType(iface);
            }
            else if (currentContainer.IsStructure() || currentContainer.IsInterface() || currentContainer.IsClass())
            {
                Structure parent = (Structure)currentContainer;
                parent.AddType(iface);
            }
            else
            {
                Error(node, "unexpected place for a class.");
            }

            // Push the interface unsafe.
            if (iface.IsUnsafe())
            {
                PushUnsafe();
            }

            // Update the scope.
            PushScope(iface);

            // Visit the building children.
            VisitList(node.GetChildren());

            // Restore the scope.
            PopScope();

            // Restore the generic scope.
            if (protoScope != null)
            {
                PopScope();
            }

            // Pop the interface unsafe.
            if (iface.IsUnsafe())
            {
                PopUnsafe();
            }

            return(node);
        }
        public override AstNode Visit(StructDefinition node)
        {
            // Parse the generic signature.
            GenericSignature genericSign = node.GetGenericSignature();
            GenericPrototype genProto    = GenericPrototype.Empty;
            PseudoScope      protoScope  = null;

            if (genericSign != null)
            {
                // Visit the generic signature.
                genericSign.Accept(this);

                // Connect the generic prototype.
                genProto = genericSign.GetPrototype();

                // Create the placeholders scope.
                protoScope = new PseudoScope(currentScope, genProto);
                node.SetGenericScope(protoScope);
            }

            // Prevent redefinition.
            ScopeMember old = currentContainer.FindType(node.GetName(), genProto);

            if (old != null)
            {
                Error(node, "trying to redefine a struct.");
            }

            // Create the structure
            Structure building = new Structure(node.GetName(), node.GetFlags(), currentContainer);

            building.SetGenericPrototype(genProto);
            node.SetStructure(building);
            building.Position = node.GetPosition();

            // Use the prototype scope.
            if (protoScope != null)
            {
                PushScope(protoScope);
            }

            // Register type association.
            string     fullName = building.GetFullName();
            IChelaType assoc;

            if (assocClasses.TryGetValue(fullName, out assoc))
            {
                currentModule.RegisterAssociatedClass(assoc, building);
            }

            // Add into the current scope.
            if (currentContainer.IsNamespace())
            {
                Namespace space = (Namespace)currentContainer;
                space.AddType(building);
            }
            else if (currentContainer.IsStructure() || currentContainer.IsInterface() || currentContainer.IsClass())
            {
                Structure parent = (Structure)currentContainer;
                parent.AddType(building);
            }
            else
            {
                Error(node, "unexpected place for a structure.");
            }

            // Push the building unsafe.
            if (building.IsUnsafe())
            {
                PushUnsafe();
            }

            // Update the scope.
            PushScope(building);

            // Visit the building children.
            VisitList(node.GetChildren());

            // Restore the scope.
            PopScope();

            // Pop the building unsafe.
            if (building.IsUnsafe())
            {
                PopUnsafe();
            }

            // Restore the prototype scope.
            if (protoScope != null)
            {
                PopScope();
            }

            return(node);
        }