← Back to branch summary

~ubuntu-branches/ubuntu/saucy/monodevelop/saucy-proposed

« back to all changes in this revision

Viewing changes to contrib/ICSharpCode.NRefactory.CSharp/Resolver/ResolveVisitor.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2012-06-22 20:35:35 UTC
  • mfrom: (10.3.2)
  • Revision ID: package-import@ubuntu.com-20120622203535-zrozwvcf6kfk6l6i
Tags: 3.0.3.2+dfsg-1
* [3fd89ae] Imported Upstream version 3.0.3.2+dfsg
* [379a680] Remove old patches we haven't used for ages from git.
* [d71161d] Remove correct_paths_in_monodevelop-core-addins.pc.patch.
  Upstream claim to have fixed this by moving assembly install locations.
* [15dbfb9] Fix install location for MonoDevelop.Gettext.dll.config.
* [26eb434] Fix install location for MonoDevelop.SourceEditor2.dll.config.
* [4169974] Upstream commit 53282c9 which finally reconciles the 
  MonoDevelop.Gettext.dll install location with the 
  monodevelop-core-addins.pc location.

Show diffs side-by-side

added added

removed removed

Lines of Context:
contrib/ICSharpCode.NRefactory.CSharp/Resolver/ResolveVisitor.cs
515
515
                {
516
516
                        CSharpResolver previousResolver = resolver;
517
517
                        try {
518
 
                                if (parsedFile != null)
 
518
                                if (parsedFile != null) {
519
519
                                        resolver = resolver.WithCurrentUsingScope(parsedFile.RootUsingScope.Resolve(resolver.Compilation));
 
520
                                } else {
 
521
                                        var cv = new TypeSystemConvertVisitor(unit.FileName ?? string.Empty);
 
522
                                        ApplyVisitorToUsings(cv, unit.Children);
 
523
                                        PushUsingScope(cv.ParsedFile.RootUsingScope);
 
524
                                }
520
525
                                ScanChildren(unit);
521
526
                                return voidResult;
522
527
                        } finally {
524
529
                        }
525
530
                }
526
531
                
 
532
                void ApplyVisitorToUsings(TypeSystemConvertVisitor visitor, IEnumerable<AstNode> children)
 
533
                {
 
534
                        foreach (var child in children) {
 
535
                                if (child is ExternAliasDeclaration || child is UsingDeclaration || child is UsingAliasDeclaration) {
 
536
                                        child.AcceptVisitor(visitor);
 
537
                                }
 
538
                        }
 
539
                }
 
540
                
 
541
                void PushUsingScope(UsingScope usingScope)
 
542
                {
 
543
                        usingScope.Freeze();
 
544
                        resolver = resolver.WithCurrentUsingScope(new ResolvedUsingScope(resolver.CurrentTypeResolveContext, usingScope));
 
545
                }
 
546
                
527
547
                ResolveResult IAstVisitor<ResolveResult>.VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration)
528
548
                {
529
549
                        CSharpResolver previousResolver = resolver;
530
550
                        try {
531
551
                                if (parsedFile != null) {
532
552
                                        resolver = resolver.WithCurrentUsingScope(parsedFile.GetUsingScope(namespaceDeclaration.StartLocation).Resolve(resolver.Compilation));
 
553
                                } else {
 
554
                                        string fileName = namespaceDeclaration.GetRegion().FileName ?? string.Empty;
 
555
                                        // Fetch parent using scope
 
556
                                        // Create root using scope if necessary
 
557
                                        if (resolver.CurrentUsingScope == null)
 
558
                                                PushUsingScope(new UsingScope());
 
559
                                        
 
560
                                        // Create child using scope
 
561
                                        DomRegion region = namespaceDeclaration.GetRegion();
 
562
                                        var identifiers = namespaceDeclaration.Identifiers.ToList();
 
563
                                        // For all but the last identifier:
 
564
                                        UsingScope usingScope;
 
565
                                        for (int i = 0; i < identifiers.Count - 1; i++) {
 
566
                                                usingScope = new UsingScope(resolver.CurrentUsingScope.UnresolvedUsingScope, identifiers[i].Name);
 
567
                                                usingScope.Region = region;
 
568
                                                PushUsingScope(usingScope);
 
569
                                        }
 
570
                                        // Last using scope:
 
571
                                        usingScope = new UsingScope(resolver.CurrentUsingScope.UnresolvedUsingScope, identifiers.Last().Name);
 
572
                                        usingScope.Region = region;
 
573
                                        var cv = new TypeSystemConvertVisitor(new CSharpParsedFile(region.FileName ?? string.Empty), usingScope);
 
574
                                        ApplyVisitorToUsings(cv, namespaceDeclaration.Children);
 
575
                                        PushUsingScope(usingScope);
533
576
                                }
534
577
                                ScanChildren(namespaceDeclaration);
535
578
                                // merge undecided lambdas before leaving the using scope so that
591
634
                #region Track CurrentMember
592
635
                ResolveResult IAstVisitor<ResolveResult>.VisitFieldDeclaration(FieldDeclaration fieldDeclaration)
593
636
                {
594
 
                        return VisitFieldOrEventDeclaration(fieldDeclaration);
 
637
                        return VisitFieldOrEventDeclaration(fieldDeclaration, EntityType.Field);
595
638
                }
596
639
                
597
640
                ResolveResult IAstVisitor<ResolveResult>.VisitFixedFieldDeclaration(FixedFieldDeclaration fixedFieldDeclaration)
598
641
                {
599
 
                        return VisitFieldOrEventDeclaration(fixedFieldDeclaration);
 
642
                        return VisitFieldOrEventDeclaration(fixedFieldDeclaration, EntityType.Field);
600
643
                }
601
644
                
602
645
                ResolveResult IAstVisitor<ResolveResult>.VisitEventDeclaration(EventDeclaration eventDeclaration)
603
646
                {
604
 
                        return VisitFieldOrEventDeclaration(eventDeclaration);
 
647
                        return VisitFieldOrEventDeclaration(eventDeclaration, EntityType.Event);
605
648
                }
606
649
                
607
 
                ResolveResult VisitFieldOrEventDeclaration(EntityDeclaration fieldOrEventDeclaration)
 
650
                ResolveResult VisitFieldOrEventDeclaration(EntityDeclaration fieldOrEventDeclaration, EntityType entityType)
608
651
                {
609
652
                        //int initializerCount = fieldOrEventDeclaration.GetChildrenByRole(Roles.Variable).Count;
610
653
                        CSharpResolver oldResolver = resolver;
611
654
                        for (AstNode node = fieldOrEventDeclaration.FirstChild; node != null; node = node.NextSibling) {
612
655
                                if (node.Role == Roles.Variable) {
613
 
                                        resolver = resolver.WithCurrentMember(GetMemberFromLocation(node.StartLocation));
 
656
                                        IMember member;
 
657
                                        if (parsedFile != null) {
 
658
                                                member = GetMemberFromLocation(node.StartLocation);
 
659
                                        } else {
 
660
                                                string name = ((VariableInitializer)node).Name;
 
661
                                                member = AbstractUnresolvedMember.Resolve(resolver.CurrentTypeResolveContext, entityType, name);
 
662
                                        }
 
663
                                        resolver = resolver.WithCurrentMember(member);
614
664
                                        
615
665
                                        Scan(node);
616
666
                                        
717
767
                        }
718
768
                }
719
769
                
720
 
                ResolveResult VisitMethodMember(EntityDeclaration member)
 
770
                ResolveResult VisitMethodMember(EntityDeclaration memberDeclaration)
721
771
                {
722
772
                        CSharpResolver oldResolver = resolver;
723
773
                        try {
724
 
                                resolver = resolver.WithCurrentMember(GetMemberFromLocation(member.StartLocation));
725
 
                                
726
 
                                ScanChildren(member);
727
 
                                
728
 
                                if (resolver.CurrentMember != null)
729
 
                                        return new MemberResolveResult(null, resolver.CurrentMember, false);
 
774
                                IMember member;
 
775
                                if (parsedFile != null) {
 
776
                                        member = GetMemberFromLocation(memberDeclaration.StartLocation);
 
777
                                } else {
 
778
                                        // Re-discover the method:
 
779
                                        EntityType entityType = memberDeclaration.EntityType;
 
780
                                        var parameterTypes = TypeSystemConvertVisitor.GetParameterTypes(memberDeclaration.GetChildrenByRole(Roles.Parameter));
 
781
                                        if (entityType == EntityType.Constructor) {
 
782
                                                string name = memberDeclaration.HasModifier(Modifiers.Static) ? ".cctor" : ".ctor";
 
783
                                                member = AbstractUnresolvedMember.Resolve(
 
784
                                                        resolver.CurrentTypeResolveContext, entityType, name,
 
785
                                                        parameterTypeReferences: parameterTypes);
 
786
                                        } else if (entityType == EntityType.Destructor) {
 
787
                                                member = AbstractUnresolvedMember.Resolve(resolver.CurrentTypeResolveContext, entityType, "Finalize");
 
788
                                        } else {
 
789
                                                string[] typeParameterNames = memberDeclaration.GetChildrenByRole(Roles.TypeParameter).Select(tp => tp.Name).ToArray();
 
790
                                                AstType explicitInterfaceAstType = memberDeclaration.GetChildByRole(EntityDeclaration.PrivateImplementationTypeRole);
 
791
                                                ITypeReference explicitInterfaceType = null;
 
792
                                                if (!explicitInterfaceAstType.IsNull) {
 
793
                                                        explicitInterfaceType = explicitInterfaceAstType.ToTypeReference();
 
794
                                                }
 
795
                                                member = AbstractUnresolvedMember.Resolve(
 
796
                                                        resolver.CurrentTypeResolveContext, entityType, memberDeclaration.Name,
 
797
                                                        explicitInterfaceType, typeParameterNames, parameterTypes);
 
798
                                        }
 
799
                                }
 
800
                                resolver = resolver.WithCurrentMember(member);
 
801
                                ScanChildren(memberDeclaration);
 
802
                                
 
803
                                if (member != null)
 
804
                                        return new MemberResolveResult(null, member, false);
730
805
                                else
731
806
                                        return errorResult;
732
807
                        } finally {
759
834
                {
760
835
                        CSharpResolver oldResolver = resolver;
761
836
                        try {
762
 
                                resolver = resolver.WithCurrentMember(GetMemberFromLocation(propertyOrIndexerDeclaration.StartLocation));
 
837
                                IMember member;
 
838
                                if (parsedFile != null) {
 
839
                                        member = GetMemberFromLocation(propertyOrIndexerDeclaration.StartLocation);
 
840
                                } else {
 
841
                                        // Re-discover the property:
 
842
                                        string name = propertyOrIndexerDeclaration.Name;
 
843
                                        var parameterTypeReferences = TypeSystemConvertVisitor.GetParameterTypes(propertyOrIndexerDeclaration.GetChildrenByRole(Roles.Parameter));
 
844
                                        AstType explicitInterfaceAstType = propertyOrIndexerDeclaration.GetChildByRole(EntityDeclaration.PrivateImplementationTypeRole);
 
845
                                        ITypeReference explicitInterfaceType = null;
 
846
                                        if (!explicitInterfaceAstType.IsNull) {
 
847
                                                explicitInterfaceType = explicitInterfaceAstType.ToTypeReference();
 
848
                                        }
 
849
                                        member = AbstractUnresolvedMember.Resolve(
 
850
                                                resolver.CurrentTypeResolveContext, propertyOrIndexerDeclaration.EntityType, name,
 
851
                                                explicitInterfaceType, parameterTypeReferences: parameterTypeReferences);
 
852
                                }
 
853
                                resolver = resolver.WithCurrentMember(member);
763
854
                                
764
855
                                for (AstNode node = propertyOrIndexerDeclaration.FirstChild; node != null; node = node.NextSibling) {
765
 
                                        if (node.Role == PropertyDeclaration.SetterRole && resolver.CurrentMember != null) {
 
856
                                        if (node.Role == PropertyDeclaration.SetterRole && member != null) {
766
857
                                                resolver = resolver.PushBlock();
767
 
                                                resolver = resolver.AddVariable(new DefaultParameter(resolver.CurrentMember.ReturnType, "value"));
 
858
                                                resolver = resolver.AddVariable(new DefaultParameter(member.ReturnType, "value"));
768
859
                                                Scan(node);
769
860
                                                resolver = resolver.PopBlock();
770
861
                                        } else {
771
862
                                                Scan(node);
772
863
                                        }
773
864
                                }
774
 
                                if (resolver.CurrentMember != null)
775
 
                                        return new MemberResolveResult(null, resolver.CurrentMember, false);
 
865
                                if (member != null)
 
866
                                        return new MemberResolveResult(null, member, false);
776
867
                                else
777
868
                                        return errorResult;
778
869
                        } finally {
794
885
                {
795
886
                        CSharpResolver oldResolver = resolver;
796
887
                        try {
797
 
                                resolver = resolver.WithCurrentMember(GetMemberFromLocation(eventDeclaration.StartLocation));
 
888
                                IMember member;
 
889
                                if (parsedFile != null) {
 
890
                                        member = GetMemberFromLocation(eventDeclaration.StartLocation);
 
891
                                } else {
 
892
                                        string name = eventDeclaration.Name;
 
893
                                        AstType explicitInterfaceAstType = eventDeclaration.PrivateImplementationType;
 
894
                                        if (explicitInterfaceAstType.IsNull) {
 
895
                                                member = AbstractUnresolvedMember.Resolve(resolver.CurrentTypeResolveContext, EntityType.Event, name);
 
896
                                        } else {
 
897
                                                member = AbstractUnresolvedMember.Resolve(resolver.CurrentTypeResolveContext, EntityType.Event, name,
 
898
                                                                                          explicitInterfaceAstType.ToTypeReference());
 
899
                                        }
 
900
                                }
 
901
                                resolver = resolver.WithCurrentMember(member);
798
902
                                
799
 
                                if (resolver.CurrentMember != null) {
 
903
                                if (member != null) {
800
904
                                        resolver = resolver.PushBlock();
801
 
                                        resolver = resolver.AddVariable(new DefaultParameter(resolver.CurrentMember.ReturnType, "value"));
 
905
                                        resolver = resolver.AddVariable(new DefaultParameter(member.ReturnType, "value"));
802
906
                                        ScanChildren(eventDeclaration);
803
907
                                } else {
804
908
                                        ScanChildren(eventDeclaration);
805
909
                                }
806
910
                                
807
 
                                if (resolver.CurrentMember != null)
808
 
                                        return new MemberResolveResult(null, resolver.CurrentMember, false);
 
911
                                if (member != null)
 
912
                                        return new MemberResolveResult(null, member, false);
809
913
                                else
810
914
                                        return errorResult;
811
915
                        } finally {
876
980
                        try {
877
981
                                // Scan enum member attributes before setting resolver.CurrentMember, so that
878
982
                                // enum values used as attribute arguments have the correct type.
879
 
                                // (which an enum member, all other enum members are treated as having their underlying type)
 
983
                                // (within an enum member, all other enum members are treated as having their underlying type)
880
984
                                foreach (var attributeSection in enumMemberDeclaration.Attributes)
881
985
                                        Scan(attributeSection);
882
986
                                
883
 
                                resolver = resolver.WithCurrentMember(GetMemberFromLocation(enumMemberDeclaration.StartLocation));
 
987
                                IMember member = null;
 
988
                                if (parsedFile != null) {
 
989
                                        member = GetMemberFromLocation(enumMemberDeclaration.StartLocation);
 
990
                                } else if (resolver.CurrentTypeDefinition != null) {
 
991
                                        string name = enumMemberDeclaration.Name;
 
992
                                        member = resolver.CurrentTypeDefinition.GetFields(f => f.Name == name, GetMemberOptions.IgnoreInheritedMembers).FirstOrDefault();
 
993
                                }
 
994
                                resolver = resolver.WithCurrentMember(member);
884
995
                                
885
996
                                if (resolverEnabled && resolver.CurrentTypeDefinition != null) {
886
997
                                        ResolveAndProcessConversion(enumMemberDeclaration.Initializer, resolver.CurrentTypeDefinition.EnumUnderlyingType);
887
 
                                        if (resolverEnabled && resolver.CurrentMember != null)
888
 
                                                return new MemberResolveResult(null, resolver.CurrentMember, false);
 
998
                                        if (resolverEnabled && member != null)
 
999
                                                return new MemberResolveResult(null, member, false);
889
1000
                                        else
890
1001
                                                return errorResult;
891
1002
                                } else {
977
1088
                        return null;
978
1089
                }
979
1090
                
 
1091
                class AnonymousTypeMember
 
1092
                {
 
1093
                        public readonly Expression Expression;
 
1094
                        public readonly ResolveResult Initializer;
 
1095
                        
 
1096
                        public AnonymousTypeMember(Expression expression, ResolveResult initializer)
 
1097
                        {
 
1098
                                this.Expression = expression;
 
1099
                                this.Initializer = initializer;
 
1100
                        }
 
1101
                }
 
1102
                
980
1103
                ResolveResult IAstVisitor<ResolveResult>.VisitAnonymousTypeCreateExpression(AnonymousTypeCreateExpression anonymousTypeCreateExpression)
981
1104
                {
982
1105
                        // 7.6.10.6 Anonymous object creation expressions
983
 
                        List<IUnresolvedProperty> properties = new List<IUnresolvedProperty>();
984
 
                        var initializers = anonymousTypeCreateExpression.Initializers;
985
 
                        foreach (var expr in initializers) {
 
1106
                        List<IUnresolvedProperty> unresolvedProperties = new List<IUnresolvedProperty>();
 
1107
                        List<AnonymousTypeMember> members = new List<AnonymousTypeMember>();
 
1108
                        foreach (var expr in anonymousTypeCreateExpression.Initializers) {
986
1109
                                Expression resolveExpr;
987
1110
                                var name = GetAnonymousTypePropertyName(expr, out resolveExpr);
988
1111
                                if (resolveExpr != null) {
989
 
                                        var returnType = Resolve(resolveExpr).Type;
990
 
                                        var returnTypeRef = returnType.ToTypeReference();
 
1112
                                        var initRR = Resolve(resolveExpr);
 
1113
                                        var returnTypeRef = initRR.Type.ToTypeReference();
991
1114
                                        var property = new DefaultUnresolvedProperty {
992
1115
                                                Name = name,
993
1116
                                                Accessibility = Accessibility.Public,
998
1121
                                                        ReturnType = returnTypeRef
999
1122
                                                }
1000
1123
                                        };
1001
 
                                        properties.Add(property);
1002
 
                                }
1003
 
                        }
1004
 
                        var anonymousType = new AnonymousType(resolver.Compilation, properties);
1005
 
                        foreach (var pair in initializers.Zip(anonymousType.GetProperties(), (expr, prop) => new { expr = expr as NamedExpression, prop })) {
1006
 
                                if (pair.expr != null) {
1007
 
                                        StoreCurrentState(pair.expr);
1008
 
                                        // pair.expr.Expression was already resolved by the first loop
1009
 
                                        StoreResult(pair.expr, new MemberResolveResult(new ResolveResult(anonymousType), pair.prop));
1010
 
                                }
1011
 
                        }
1012
 
                        return new ResolveResult(anonymousType);
 
1124
                                        unresolvedProperties.Add(property);
 
1125
                                        members.Add(new AnonymousTypeMember(expr, initRR));
 
1126
                                } else {
 
1127
                                        Scan(expr);
 
1128
                                }
 
1129
                        }
 
1130
                        var anonymousType = new AnonymousType(resolver.Compilation, unresolvedProperties);
 
1131
                        var properties = anonymousType.GetProperties().ToList();
 
1132
                        Debug.Assert(properties.Count == members.Count);
 
1133
                        List<ResolveResult> assignments = new List<ResolveResult>();
 
1134
                        for (int i = 0; i < members.Count; i++) {
 
1135
                                ResolveResult lhs = new MemberResolveResult(new InitializedObjectResolveResult(anonymousType), properties[i]);
 
1136
                                ResolveResult rhs = members[i].Initializer;
 
1137
                                ResolveResult assignment = resolver.ResolveAssignment(AssignmentOperatorType.Assign, lhs, rhs);
 
1138
                                var ne = members[i].Expression as NamedExpression;
 
1139
                                if (ne != null) {
 
1140
                                        StoreCurrentState(ne);
 
1141
                                        // ne.Expression was already resolved by the first loop
 
1142
                                        StoreResult(ne, lhs);
 
1143
                                }
 
1144
                                assignments.Add(assignment);
 
1145
                        }
 
1146
                        var anonymousCtor = DefaultResolvedMethod.GetDummyConstructor(resolver.Compilation, anonymousType);
 
1147
                        return new InvocationResolveResult(null, anonymousCtor, initializerStatements: assignments);
1013
1148
                }
1014
1149
                #endregion
1015
1150
                
1747
1882
                
1748
1883
                DomRegion MakeRegion(AstNode node)
1749
1884
                {
1750
 
                        return new DomRegion(parsedFile != null ? parsedFile.FileName : null, node.StartLocation, node.EndLocation);
 
1885
                        if (parsedFile != null)
 
1886
                                return new DomRegion(parsedFile.FileName, node.StartLocation, node.EndLocation);
 
1887
                        else
 
1888
                                return node.GetRegion();
1751
1889
                }
1752
1890
                
1753
1891
                sealed class ExplicitlyTypedLambda : LambdaBase