public override void OutAFieldLvalue(AFieldLvalue node)
        {
            //Since we dont apply the replacement of an OutAAmbiguousNameLvalue, this node needs a link
            //Eks: global.<field>
            //Look for fields
            AFieldDecl f = null;
            APropertyDecl p = null;
            if (data.FieldLinks.ContainsKey(node))
                f = data.FieldLinks[node];
            else //if (!data.FieldLinks.ContainsKey(node) )
            {
                List<IList> visibleDecls = Util.GetVisibleDecls(node, true);
                AASourceFile currentFile = Util.GetAncestor<AASourceFile>(node);
                List<string> currentNamespace = Util.GetFullNamespace(node);
                List<PDecl> candidates = new List<PDecl>();
                foreach (IList declList in visibleDecls)
                {
                    bool isSameFile = false;
                    bool isSameNamespace = false;
                    if (declList.Count > 0)
                    {
                        isSameFile = currentFile == Util.GetAncestor<AASourceFile>((PDecl)declList[0]);
                        isSameNamespace = Util.NamespacesEquals(currentNamespace, Util.GetFullNamespace((PDecl)declList[0]));
                    }
                    foreach (PDecl decl in declList)
                    {
                        if (decl is AFieldDecl)
                        {
                            AFieldDecl field = (AFieldDecl)decl;

                            if (field.GetName().Text != node.GetName().Text)
                                continue;

                            if (!isSameNamespace && field.GetVisibilityModifier() is APrivateVisibilityModifier ||
                                !isSameFile && field.GetStatic() != null)
                                continue;

                            candidates.Add(decl);
                        }
                        else if (decl is APropertyDecl)
                        {
                            APropertyDecl property = (APropertyDecl)decl;

                            if (property.GetName().Text != node.GetName().Text)
                                continue;

                            if (!isSameNamespace && property.GetVisibilityModifier() is APrivateVisibilityModifier ||
                                !isSameFile && property.GetStatic() != null)
                                continue;

                            candidates.Add(decl);
                        }
                    }
                }

                //Lib fields
                foreach (AFieldDecl field in data.Libraries.Fields)
                {
                    if (field.GetName().Text != node.GetName().Text)
                        continue;

                    if (field.GetStatic() != null)
                        continue;

                    candidates.Add(field);
                }

                if (candidates.Count == 0)
                {
                    errors.Add(
                        new ErrorCollection.Error(node.GetName(), currentSourceFile,
                                                  node.GetName().Text + LocRM.GetString("ErrorText169"),
                                                  false), true);
                    throw new ParserException(node.GetName(), "TypeLinking.OutAFieldLvalue");
                }
                if (candidates.Count > 1)
                {
                    List<ErrorCollection.Error> subErrors = new List<ErrorCollection.Error>();
                    foreach (PDecl decl in candidates)
                    {
                        if (decl is AFieldDecl)
                        {
                            AFieldDecl field = (AFieldDecl)decl;
                            subErrors.Add(new ErrorCollection.Error(field.GetName(), LocRM.GetString("ErrorText60")));
                        }
                        else if (decl is APropertyDecl)
                        {
                            APropertyDecl field = (APropertyDecl)decl;
                            subErrors.Add(new ErrorCollection.Error(field.GetName(), LocRM.GetString("ErrorText62")));
                        }
                    }

                    errors.Add(
                        new ErrorCollection.Error(node.GetName(), currentSourceFile,
                                                  node.GetName().Text + LocRM.GetString("ErrorText170"),
                                                  false, subErrors.ToArray()), true);
                    throw new ParserException(node.GetName(), "TypeLinking.OutAFieldLvalue");
                }
                if (candidates[0] is AFieldDecl)
                    f = (AFieldDecl)candidates[0];
                else
                    p = (APropertyDecl)candidates[0];
            }

            if (f != null)
            {
                AFieldDecl field = f;
                data.FieldLinks[node] = field;
                if (foldIntegerConstants)
                {
                    if (!(field.GetType() is ANamedType && ((ANamedType)field.GetType()).IsPrimitive("int")))
                    {
                        errors.Add(
                            new ErrorCollection.Error(node.GetName(),
                                                      LocRM.GetString("ErrorText168"),
                                                      false, new ErrorCollection.Error(field.GetName(), LocRM.GetString("ErrorText60"))), true);
                        throw new ParserException(node.GetName(), "TypeLinking.OutAFieldLvalue");
                    }

                    if (field.GetConst() == null)
                    {
                        foldingFailed = true;
                        if (!isInANewExp)
                        {
                            errors.Add(
                                new ErrorCollection.Error(node.GetName(), currentSourceFile,
                                                          LocRM.GetString("ErrorText168"),
                                                          false), true);
                            throw new ParserException(node.GetName(), "TypeLinking.OutAFieldLvalue");
                        }
                    }
                    if (field.GetInit() == null)//An error will be given earlier - constant fields must have an initializer
                    {
                        throw new ParserException(node.GetName(), "TypeLinking.OutAFieldLvalue");
                    }
                    field.GetInit().Apply(this);
                }
            }
            else
            {
                APropertyDecl property = p;
                APropertyLvalue replacer = new APropertyLvalue(node.GetName());
                data.PropertyLinks.Add(replacer, property);
                node.ReplaceBy(replacer);
                data.PropertyLinks[replacer] = property;
                if (foldIntegerConstants)
                {
                    foldingFailed = true;
                    if (isInANewExp)
                    {
                        errors.Add(
                            new ErrorCollection.Error(node.GetName(), currentSourceFile,
                                                        LocRM.GetString("ErrorText168"),
                                                        false), true);
                        throw new ParserException(node.GetName(), "TypeLinking.OutAFieldLvalue");
                    }
                }
            }
        }