Store location info for declarations

Functionality to store the location of the declaration of
 * filters
 * operations
 * attributes
 * properties

lib/coll.gd

@@ -342,18 +342,22 @@ BIND_GLOBAL( "DeclareSynonym", function( name, value )
             INFO_DEBUG( 1, "multiple declarations for synonym `", name, "'\n" );
         fi;
     else
+        ADD_LIST(BIND_LOCS, [name, CURRENT_LOCATION()]);
         BIND_GLOBAL( name, value );
     fi;
 end );
 
 BIND_GLOBAL( "DeclareSynonymAttr", function( name, value )
     local nname;
+    ADD_LIST(BIND_LOCS, [name, CURRENT_LOCATION()]);
     DeclareSynonym( name, value );
     nname:= "Set";
     APPEND_LIST_INTR( nname, name );
+    ADD_LIST(BIND_LOCS, [nname, CURRENT_LOCATION()]);
     DeclareSynonym( nname, Setter( value ) );
     nname:= "Has";
     APPEND_LIST_INTR( nname, name );
+    ADD_LIST(BIND_LOCS, [nname, CURRENT_LOCATION()]);
     DeclareSynonym( nname, Tester( value ) );
 end );
 

lib/filter.g

@@ -31,7 +31,7 @@ CLEAR_IMP_CACHE := fail;
 ##  filter with number <i> resp.  its rank.
 ##
 BIND_GLOBAL( "FILTERS", [] );
-
+BIND_GLOBAL( "FILTERS_LOCATIONS", [] );
 
 #############################################################################
 ##
@@ -234,6 +234,7 @@ BIND_GLOBAL( "NewFilter", function( arg )
 
     # Do some administrational work.
     FILTERS[ FLAG1_FILTER( filter ) ] := filter;
+    FILTERS_LOCATIONS[ FLAG1_FILTER( filter ) ] := CURRENT_LOCATION();
     IMM_FLAGS:= AND_FLAGS( IMM_FLAGS, FLAGS_FILTER( filter ) );
     RANK_FILTERS[ FLAG1_FILTER( filter ) ] := rank;
     INFO_FILTERS[ FLAG1_FILTER( filter ) ] := 0;

lib/function.g

@@ -638,20 +638,17 @@ end);
 
 BIND_GLOBAL( "VIEW_STRING_OPERATION",    function ( op )
     local   class,  flags,  types,  catok,  repok,  propok,  seenprop,
-            t, res;
+            t, flafs, res;
     class := "Operation";
     if IS_IDENTICAL_OBJ(op,IS_OBJECT) then
         class := "Filter";
     elif IS_CONSTRUCTOR(op) then
         class := "Constructor";
     elif IsFilter(op) then
         class := "Filter";
-        flags := FLAGS_FILTER(op);
-        if flags <> false then
-            flags := TRUES_FLAGS(flags);
-        else
-            flags := [];
-        fi;
+        flafs := FLAGS_FILTER(op);
+        if flafs <> false then
+        flags := TRUES_FLAGS(FLAGS_FILTER(op));
         types := INFO_FILTERS{flags};
         catok := true;
         repok := true;
@@ -678,6 +675,7 @@ BIND_GLOBAL( "VIEW_STRING_OPERATION",    function ( op )
         elif repok then
             class := "Representation";
         fi;
+        fi;
     elif Tester(op) <> false  then
         # op is an attribute
         class := "Attribute";

lib/global.gi

@@ -217,6 +217,7 @@ InstallGlobalFunction( BindGlobal,
         function (name, value)
     CheckGlobalName( name );
     Info( InfoGlobal, 2, "BindGlobal: called to set ", name, " to ", value);
+    ADD_LIST( BIND_LOCS, [ name, CURRENT_LOCATION() ] ); 
     BIND_GLOBAL( name, value );
 end);
 

lib/oper.g

@@ -148,7 +148,14 @@ BIND_GLOBAL( "NUMBERS_PROPERTY_GETTERS", [] );
 ##  </ManSection>
 ##
 BIND_GLOBAL( "OPERATIONS", [] );
-
+BIND_GLOBAL( "OPERATIONS_LOCATIONS", []);
+BIND_GLOBAL( "ADD_OPERATION",
+function(oper, filt)
+    ADD_LIST(OPERATIONS, oper);
+    ADD_LIST(OPERATIONS, filt);
+    OPERATIONS_LOCATIONS[LENGTH(OPERATIONS)] :=
+             [ CURRENT_LOCATION() ];
+end);
 
 #############################################################################
 ##
@@ -567,8 +574,7 @@ BIND_GLOBAL( "NewOperation", function ( name, filters )
         fi;
         ADD_LIST( filt, FLAGS_FILTER( filter ) );
     od;
-    ADD_LIST( OPERATIONS, oper );
-    ADD_LIST( OPERATIONS, [ filt ] );
+    ADD_OPERATION( oper, [ filt ] );
     return oper;
 end );
 
@@ -694,8 +700,7 @@ BIND_GLOBAL( "NewConstructor", function ( name, filters )
         ADD_LIST( filt, FLAGS_FILTER( filter ) );
     od;
     ADD_LIST( CONSTRUCTORS, oper );
-    ADD_LIST( OPERATIONS,   oper );
-    ADD_LIST( OPERATIONS,   [ filt ] );
+    ADD_OPERATION( oper, [ filt ] );
     return oper;
 end );
 
@@ -780,6 +785,7 @@ BIND_GLOBAL( "DeclareOperation", function ( name, filters )
         fi;
       else
         ADD_LIST( OPERATIONS[ pos+1 ], filt );
+        ADD_LIST( OPERATIONS_LOCATIONS[ pos + 1 ], CURRENT_LOCATION());
       fi;
 
     else
@@ -824,8 +830,7 @@ BIND_GLOBAL( "DeclareOperationKernel", function ( name, filters, oper )
         ADD_LIST( filt, FLAGS_FILTER( filter ) );
     od;
 
-    ADD_LIST( OPERATIONS, oper );
-    ADD_LIST( OPERATIONS, [ filt ] );
+    ADD_OPERATION( oper, [ filt ] );
 end );
 
 
@@ -882,7 +887,7 @@ BIND_GLOBAL( "DeclareConstructor", function ( name, filters )
 
       pos:= POS_LIST_DEFAULT( OPERATIONS, gvar, 0 );
       ADD_LIST( OPERATIONS[ pos+1 ], filt );
-
+      ADD_LIST( OPERATIONS_LOCATIONS[ pos + 1 ], CURRENT_LOCATION() );
     else
 
       # The operation is new.
@@ -926,8 +931,7 @@ BIND_GLOBAL( "DeclareConstructorKernel", function ( name, filters, oper )
     od;
 
     ADD_LIST( CONSTRUCTORS, oper );
-    ADD_LIST( OPERATIONS,   oper );
-    ADD_LIST( OPERATIONS,   [ filt ] );
+    ADD_OPERATION( oper, [ filt ] );
 end );
 
 
@@ -964,7 +968,8 @@ BIND_GLOBAL( "RUN_ATTR_FUNCS",
     for func in ATTR_FUNCS do
         func( name, filter, getter, setter, tester, mutflag );
     od;
-    ADD_LIST( ATTRIBUTES, [ name, filter, getter, setter, tester, mutflag ] );
+    ADD_LIST( ATTRIBUTES, [ name, filter, getter, setter, tester, mutflag,
+                            CURRENT_LOCATION() ] );
 end );
 
 
@@ -993,16 +998,13 @@ BIND_GLOBAL( "DeclareAttributeKernel", function ( name, filter, getter )
     tester := TESTER_FILTER( getter );
 
     # add getter, setter and tester to the list of operations
-    ADD_LIST( OPERATIONS, getter );
-    ADD_LIST( OPERATIONS, [ [ FLAGS_FILTER(filter) ] ] );
-    ADD_LIST( OPERATIONS, setter );
-    ADD_LIST( OPERATIONS,
-              [ [ FLAGS_FILTER( filter ), FLAGS_FILTER( IS_OBJECT ) ] ] );
-    ADD_LIST( OPERATIONS, tester );
-    ADD_LIST( OPERATIONS, [ [ FLAGS_FILTER(filter) ] ] );
+    ADD_OPERATION( getter, [ [ FLAGS_FILTER(filter) ] ] );
+    ADD_OPERATION( setter, [ [ FLAGS_FILTER( filter ), FLAGS_FILTER( IS_OBJECT ) ] ] );
+    ADD_OPERATION( tester, [ [ FLAGS_FILTER(filter) ] ] );
 
     # store the information about the filter
     FILTERS[ FLAG2_FILTER( tester ) ] := tester;
+    FILTERS_LOCATIONS[ FLAG2_FILTER( tester ) ] := CURRENT_LOCATION();
     IMM_FLAGS:= AND_FLAGS( IMM_FLAGS, FLAGS_FILTER( tester ) );
     INFO_FILTERS[ FLAG2_FILTER( tester ) ] := 5;
 
@@ -1089,13 +1091,12 @@ BIND_GLOBAL( "OPER_SetupAttribute", function(getter, flags, mutflag, filter, ran
           setter := SETTER_FILTER( getter );
           tester := TESTER_FILTER( getter );
 
-          ADD_LIST( OPERATIONS, setter );
-          ADD_LIST( OPERATIONS, [ [ flags, FLAGS_FILTER( IS_OBJECT ) ] ] );
-          ADD_LIST( OPERATIONS, tester );
-          ADD_LIST( OPERATIONS, [ [ flags ] ] );
+          ADD_OPERATION( setter, [ [ flags, FLAGS_FILTER( IS_OBJECT ) ] ] );
+          ADD_OPERATION( tester, [ [ flags ] ] );
 
           # install the default functions
           FILTERS[ FLAG2_FILTER( tester ) ] := tester;
+          FILTERS_LOCATIONS[ FLAG2_FILTER( tester ) ] := CURRENT_LOCATION();
           IMM_FLAGS:= AND_FLAGS( IMM_FLAGS, FLAGS_FILTER( tester ) );
 
           # the <tester> is newly made, therefore  the cache cannot contain a  flag
@@ -1117,6 +1118,7 @@ BIND_GLOBAL( "OPER_SetupAttribute", function(getter, flags, mutflag, filter, ran
 BIND_GLOBAL( "NewAttribute", function ( arg )
     local   name, filter, flags, mutflag, getter, setter, tester, rank;
 
+    # Print("Attribute: ", CurrentLocation(), "\n");
     # construct getter, setter and tester
     name   := arg[1];
     filter := arg[2];
@@ -1140,8 +1142,7 @@ BIND_GLOBAL( "NewAttribute", function ( arg )
     else
         rank := 1;
     fi;
-    ADD_LIST(OPERATIONS,getter);
-    ADD_LIST(OPERATIONS, [ [ flags ] ]);
+    ADD_OPERATION(getter, [ [ flags ] ] );
     OPER_SetupAttribute(getter, flags, mutflag, filter, rank, name);
     # store the information about the filtera
     # And return the getter
@@ -1316,18 +1317,16 @@ BIND_GLOBAL( "DeclarePropertyKernel", function ( name, filter, getter )
     ADD_LIST( NUMBERS_PROPERTY_GETTERS, FLAG1_FILTER( getter ) );
 
     # add getter, setter and tester to the list of operations
-    ADD_LIST( OPERATIONS, getter );
-    ADD_LIST( OPERATIONS, [ [ FLAGS_FILTER(filter) ] ] );
-    ADD_LIST( OPERATIONS, setter );
-    ADD_LIST( OPERATIONS,
-              [ [ FLAGS_FILTER( filter ), FLAGS_FILTER( IS_BOOL ) ] ] );
-    ADD_LIST( OPERATIONS, tester );
-    ADD_LIST( OPERATIONS, [ [ FLAGS_FILTER(filter) ] ] );
+    ADD_OPERATION( getter, [ [ FLAGS_FILTER(filter) ] ] );
+    ADD_OPERATION( setter, [ [ FLAGS_FILTER( filter ), FLAGS_FILTER( IS_BOOL ) ] ] );
+    ADD_OPERATION( tester, [ [ FLAGS_FILTER(filter) ] ] );
 
     # install the default functions
     FILTERS[ FLAG1_FILTER( getter ) ]:= getter;
+    FILTERS_LOCATIONS[ FLAG1_FILTER( getter ) ]:= CURRENT_LOCATION();
     IMM_FLAGS:= AND_FLAGS( IMM_FLAGS, FLAGS_FILTER( getter ) );
     FILTERS[ FLAG2_FILTER( getter ) ]:= tester;
+    FILTERS_LOCATIONS[ FLAG2_FILTER( getter ) ]:= CURRENT_LOCATION();
     INFO_FILTERS[ FLAG1_FILTER( getter ) ]:= 7;
     INFO_FILTERS[ FLAG2_FILTER( getter ) ]:= 8;
 
@@ -1392,20 +1391,19 @@ BIND_GLOBAL( "NewProperty", function ( arg )
     tester := TESTER_FILTER( getter );
 
     # add getter, setter and tester to the list of operations
-    ADD_LIST( OPERATIONS, getter );
-    ADD_LIST( OPERATIONS, [ [ flags ] ] );
-    ADD_LIST( OPERATIONS, setter );
-    ADD_LIST( OPERATIONS, [ [ flags, FLAGS_FILTER( IS_BOOL ) ] ] );
-    ADD_LIST( OPERATIONS, tester );
-    ADD_LIST( OPERATIONS, [ [ flags ] ] );
+    ADD_OPERATION( getter, [ [ flags ] ] );
+    ADD_OPERATION( setter, [ [ flags, FLAGS_FILTER( IS_BOOL ) ] ] );
+    ADD_OPERATION( tester, [ [ flags ] ] );
 
     # store the property getters
     ADD_LIST( NUMBERS_PROPERTY_GETTERS, FLAG1_FILTER( getter ) );
 
     # install the default functions
     FILTERS[ FLAG1_FILTER( getter ) ] := getter;
+    FILTERS_LOCATIONS[ FLAG1_FILTER( getter ) ] := CURRENT_LOCATION();
     IMM_FLAGS:= AND_FLAGS( IMM_FLAGS, FLAGS_FILTER( getter ) );
     FILTERS[ FLAG2_FILTER( getter ) ] := tester;
+    FILTERS_LOCATIONS[ FLAG2_FILTER( getter ) ] := CURRENT_LOCATION();
     INFO_FILTERS[ FLAG1_FILTER( getter ) ] := 9;
     INFO_FILTERS[ FLAG2_FILTER( getter ) ] := 10;
 
@@ -1760,12 +1758,15 @@ end );
 ##  mechanism.
 ##
 BIND_GLOBAL( "GLOBAL_FUNCTION_NAMES", [] );
+BIND_GLOBAL( "GLOBAL_FUNCTION_DECL_LOCS", [] );
+BIND_GLOBAL( "GLOBAL_FUNCTION_INST_LOCS", [] );
 
 BIND_GLOBAL( "DeclareGlobalFunction", function( arg )
     local   name;
 
     name := arg[1];
     ADD_SET( GLOBAL_FUNCTION_NAMES, IMMUTABLE_COPY_OBJ(name) );
+    ADD_SET( GLOBAL_FUNCTION_DECL_LOCS, [IMMUTABLE_COPY_OBJ(name), CURRENT_LOCATION()]);
     BIND_GLOBAL( name, NEW_OPERATION_ARGS( name ) );
 end );
 
@@ -1787,6 +1788,7 @@ BIND_GLOBAL( "InstallGlobalFunction", function( arg )
       Error("you cannot install a global function for another global ",
             "function,\nuse `DeclareSynonym' instead!");
     fi;
+    ADD_SET( GLOBAL_FUNCTION_INST_LOCS, [NAME_FUNC(oper), CURRENT_LOCATION()]);
     INSTALL_METHOD_ARGS( oper, func );
 end );
 

lib/oper1.g

@@ -23,6 +23,11 @@
 RUN_IMMEDIATE_METHODS_CHECKS := 0;
 RUN_IMMEDIATE_METHODS_HITS   := 0;
 
+# This is a bit of a hack, after all I could try and store this in the methods
+# information list, but adding an entry there is dangerous, because everyone
+# implicitly assumes the entries to be in groups of 5.
+METHOD_LOCATIONS :=  [];
+
 BIND_GLOBAL( "RunImmediateMethods", function ( obj, flags )
 
     local   flagspos,   # list of `true' positions in `flags'
@@ -227,8 +232,17 @@ BIND_GLOBAL( "INSTALL_METHOD_FLAGS",
               ": <method> must be a function, `true', or `false'" );
     fi;
     methods[i+(narg+3)] := rank;
-
     methods[i+(narg+4)] := IMMUTABLE_COPY_OBJ(info);
+    # This is a horrible hack because I don't want to change the length
+    # of METHODS_OPERATION at the moment
+    ADD_LIST( METHOD_LOCATIONS,
+              [ opr,
+                method,
+                narg,
+                flags,
+                rank,
+                rec( line := INPUT_LINENUMBER(), file := INPUT_FILENAME() ) ] );
+
 
     # flush the cache
     CHANGED_METHODS_OPERATION( opr, narg );

lib/read1.g

@@ -4,6 +4,12 @@
 #X  after this file is read an 'ExportToKernelFinished' is done.
 ##
 ReadLib( "hpc/thread1.g" );
+BIND_GLOBAL( "CURRENT_LOCATION",
+function()
+    return rec( line := INPUT_LINENUMBER(),
+                file := INPUT_FILENAME() );
+end);
+BIND_GLOBAL( "BIND_LOCS", [] );
 ReadLib( "filter.g"    );
 ReadLib( "filter1.g"   );
 ReadLib( "oper.g"      );

lib/type.g

@@ -63,6 +63,7 @@ BIND_GLOBAL( "DeclareCategoryKernel", function ( name, super, cat )
     if not IS_IDENTICAL_OBJ( cat, IS_OBJECT ) then
         ADD_LIST( CATS_AND_REPS, FLAG1_FILTER( cat ) );
         FILTERS[ FLAG1_FILTER( cat ) ] := cat;
+        FILTERS_LOCATIONS[ FLAG1_FILTER( cat ) ] := CURRENT_LOCATION();
         IMM_FLAGS:= AND_FLAGS( IMM_FLAGS, FLAGS_FILTER( cat ) );
         INFO_FILTERS[ FLAG1_FILTER( cat ) ] := 1;
         RANK_FILTERS[ FLAG1_FILTER( cat ) ] := 1;
@@ -113,6 +114,7 @@ BIND_GLOBAL( "NewCategory", function ( arg )
     # Do some administrational work.
     ADD_LIST( CATS_AND_REPS, FLAG1_FILTER( cat ) );
     FILTERS[ FLAG1_FILTER( cat ) ] := cat;
+    FILTERS_LOCATIONS[ FLAG1_FILTER( cat ) ] := CURRENT_LOCATION();
     IMM_FLAGS:= AND_FLAGS( IMM_FLAGS, FLAGS_FILTER( cat ) );
 
     if LEN_LIST( arg ) = 3 and IS_INT( arg[3] ) then
@@ -178,6 +180,7 @@ BIND_GLOBAL( "DeclareRepresentationKernel", function ( arg )
     fi;
     ADD_LIST( CATS_AND_REPS, FLAG1_FILTER( rep ) );
     FILTERS[ FLAG1_FILTER( rep ) ]       := rep;
+    FILTERS_LOCATIONS[ FLAG1_FILTER( rep ) ] := CURRENT_LOCATION();
     IMM_FLAGS:= AND_FLAGS( IMM_FLAGS, FLAGS_FILTER( rep ) );
     RANK_FILTERS[ FLAG1_FILTER( rep ) ] := 1;
     INFO_FILTERS[ FLAG1_FILTER( rep ) ] := 3;
@@ -266,6 +269,7 @@ BIND_GLOBAL( "NewRepresentation", function ( arg )
     # Do some administrational work.
     ADD_LIST( CATS_AND_REPS, FLAG1_FILTER( rep ) );
     FILTERS[ FLAG1_FILTER( rep ) ] := rep;
+    FILTERS_LOCATIONS[ FLAG1_FILTER( rep ) ] := CURRENT_LOCATION();
     IMM_FLAGS:= AND_FLAGS( IMM_FLAGS, FLAGS_FILTER( rep ) );
     RANK_FILTERS[ FLAG1_FILTER( rep ) ] := 1;
     INFO_FILTERS[ FLAG1_FILTER( rep ) ] := 4;

lib/type.gd

@@ -37,7 +37,6 @@
 DeclareOperation( "FiltersType", [ IsType ] );
 DeclareOperation( "FiltersObj", [ IsObject ] );
 
-
 #############################################################################
 ##
 #F  IsCategory( <object> )
@@ -108,3 +107,21 @@ DeclareGlobalFunction( "IsProperty" );
 ##  </ManSection>
 ##  <#/GAPDoc>
 DeclareGlobalFunction( "CategoryByName" );
+
+
+#############################################################################
+##
+#F  LocationOfDeclaration( <object> )
+##
+##  Find the location of the declaration of <object>.
+##
+##  <#GAPDoc Label="LocationOfDeclaration">
+##  <ManSection>
+##  <Func Name="LocationofDeclaration" Arg='object'/>
+##
+##  <Description>
+##  returns the location of the declaration of <A>object</A> if it is known.
+##  </Description>
+##  </ManSection>
+##  <#/GAPDoc>
+DeclareGlobalFunction( "LocationOfDeclaration" );