| blob | 64e60fae0f2cc5b14662ddbae089aa5f1fef7d4c |
1 ;;; semantic/scope.el --- Analyzer Scope Calculations
3 ;; Copyright (C) 2007-2011 Free Software Foundation, Inc.
5 ;; Author: Eric M. Ludlam <eric@siege-engine.com>
7 ;; This file is part of GNU Emacs.
9 ;; GNU Emacs is free software: you can redistribute it and/or modify
10 ;; it under the terms of the GNU General Public License as published by
11 ;; the Free Software Foundation, either version 3 of the License, or
12 ;; (at your option) any later version.
14 ;; GNU Emacs is distributed in the hope that it will be useful,
15 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
16 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 ;; GNU General Public License for more details.
19 ;; You should have received a copy of the GNU General Public License
20 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
22 ;;; Commentary:
23 ;;
24 ;; Calculate information about the current scope.
25 ;;
26 ;; Manages the current scope as a structure that can be cached on a
27 ;; per-file basis and recycled between different occurrences of
28 ;; analysis on different parts of a file.
29 ;;
30 ;; Pattern for Scope Calculation
31 ;;
32 ;; Step 1: Calculate DataTypes in Scope:
33 ;;
34 ;; a) What is in scope via using statements or local namespaces
35 ;; b) Lineage of current context. Some names drawn from step 1.
36 ;;
37 ;; Step 2: Convert type names into lists of concrete tags
38 ;;
39 ;; a) Convert each datatype into the real datatype tag
40 ;; b) Convert namespaces into the list of contents of the namespace.
41 ;; c) Merge all existing scopes together into one search list.
42 ;;
43 ;; Step 3: Local variables
44 ;;
45 ;; a) Local variables are in the master search list.
46 ;;
60 ;;; Code:
64 :documentation
67 :documentation
68 "The list of types currently in scope.
69 For C++, this would contain anonymous namespaces known, and
72 :documentation
73 "List of parents in scope w/in the body of this function.
74 Presumably, the members of these parent classes are available for access
78 Each entry is ( PARENT . PROTECTION ), where PARENT is a type, and
81 :documentation
84 :documentation
87 :documentation
90 :documentation
93 :documentation
95 )
96 "Cache used for storage of the current scope by the Semantic Analyzer.
99 ;;; METHODS
100 ;;
101 ;; Methods for basic management of the structure in semanticdb.
102 ;;
104 "Reset OBJ back to it's empty settings."
114 )
117 new-tags)
118 "Synchronize a CACHE with some NEW-TAGS."
123 new-tags)
124 "Synchronize a CACHE with some changed NEW-TAGS."
125 ;; If there are any includes or datatypes changed, then clear.
130 )
133 "Get the current cached scope, and reset it."
136 semantic-scope-cache)))
140 types-in-scope)
141 "Set the :typescope property on CACHE to some types.
142 TYPES-IN-SCOPE is a list of type tags whos members are
143 currently in scope. For each type in TYPES-IN-SCOPE,
144 add those members to the types list.
145 If nil, then the typescope is reset."
149 newts))
150 )
153 ;;; TAG SCOPES
154 ;;
155 ;; These fcns should be used by search routines that return a single
156 ;; tag which, in turn, may have come from a deep scope. The scope
157 ;; will be attached to the tag. Thus, in future scope based calls, a
158 ;; tag can be passed in and a scope derived from it.
161 "Close TAG, and return it. Add SCOPETAGS as a tag-local scope.
162 Stores the SCOPETAGS as a set of tag properties on the cloned tag."
164 )
166 ))
169 "Get from TAG the list of tags comprising the scope from TAG."
172 ;;; SCOPE UTILITIES
173 ;;
174 ;; Functions that do the main scope calculations
178 "Return a list of types currently in scope at POSITION.
179 This is based on what tags exist at POSITION, and any associated
183 "Return a list of types currently in scope at POSITION.
184 Use `semantic-ctxt-scoped-types' to find types."
189 ;; Lets ask if any types are currently scoped. Scoped
190 ;; classes and types provide their public methods and types
191 ;; in source code, but are unrelated hierarchically.
194 ;; Get this thing as a tag
198 ;(semantic-analyze-find-tag (car sp) 'type))
202 ;;(semantic-analyze-find-tag (semantic-tag-name (car sp)) 'type)
214 )))
216 ;;------------------------------------------------------------
218 "Return a list of types in order of nesting for the context of POSITION.
219 If POSITION is in a method with a named parent, find that parent, and
220 identify it's scope via overlay instead.
221 Optional SCOPETYPES are additional scoped entities in which our parent might
225 "Return a list of types in order of nesting for the context of POSITION.
226 If POSITION is in a method with a named parent, find that parent, and
227 identify it's scope via overlay instead.
228 Optional SCOPETYPES are additional scoped entities in which our parent might
229 be found.
230 This only finds ONE immediate parent by name. All other parents returned
231 are from nesting data types."
239 )
240 ;; In case of arg lists or some-such, throw out non-types.
244 ;; Remove duplicates
248 ;; Step 1:
249 ;; Analyze the stack of tags we are nested in as parents.
250 ;;
252 ;; If we have a pparent tag, lets go there
253 ;; an analyze that stack of tags.
257 ;; Step one, find the merged version of stack in the typecache.
260 )
261 ;; @todo - can we use the typecache ability to
262 ;; put a scope into a tag to do this?
269 ;; When there was nothing from the typecache, then just
270 ;; use what's right here.
272 ;; Add things to STACK until we cease finding tags of class type.
274 ;; Otherwise, just add this to the returnlist.
279 ))
280 )
282 ;; Only do this level of analysis for functions.
284 ;; Step 2:
285 ;; If the function tag itself has a "parent" by name, then that
286 ;; parent will exist in the scope we just calculated, so look it
287 ;; up now.
288 ;;
291 ;; We have a parent, search for it.
299 searchname
304 ptag)
306 ;; Find the next entry in the refereneced type for
307 ;; our function, and append to return list till our
308 ;; returnlist is empty.
322 )))
323 )
329 'type
330 miniscope
331 ))
332 ))
339 )
343 )))
344 )
345 returnlist
346 )))
349 "Return the full lineage of tags from PARENTS.
350 The return list is of the form ( TAG . PROTECTION ), where TAG is a tag,
351 and PROTECTION is the level of protection offered by the relationship.
352 Optional SCOPETYPES are additional scoped entities in which our parent might
356 "Return the full lineage of tags from PARENTS.
357 The return list is of the form ( TAG . PROTECTION ), where TAG is a tag,
358 and PROTECTION is the level of protection offered by the relationship.
359 Optional SCOPETYPES are additional scoped entities in which our parent might
360 be found."
363 )
374 ;; doesn't provide access to private slots?
378 ))
379 miniscope))
381 lineage))
384 ;;------------------------------------------------------------
387 "Return accessible tags when TYPELIST and PARENTLIST is in scope.
388 Tags returned are not in the global name space, but are instead
389 scoped inside a class or namespace. Such items can be referenced
394 "Return accessible tags when TYPELIST and HALFSCOPE is in scope.
395 HALFSCOPE is the current scope partially initialized.
396 Tags returned are not in the global name space, but are instead
397 scoped inside a class or namespace. Such items can be referenced
404 )
405 ;; Loop over typelist, and find and merge all namespaces matching
406 ;; the names in typelist.
410 ;; By using the typecache, our namespaces are pre-merged.
412 ))
415 ;; Loop over the types (which should be sorted by position)
416 ;; adding to the scopelist as we go, and using the scopelist
417 ;; for additional searching!
423 miniscope)
424 currentscope))
427 ;; Collect all the types (class, etc) that are in our heritage.
428 ;; These are types that we can extract members from, not those
429 ;; declared in using statements, or the like.
430 ;; Get the PARENTS including nesting scope for this location.
436 miniscope)
437 currentscope))
440 ;; Loop over all the items, and collect any type constants.
445 )
449 currentscope))
451 ;;------------------------------------------------------------
453 "Calculate the access class for TYPE as defined by the current SCOPE.
454 Access is related to the :parents in SCOPE. If type is a member of SCOPE
455 then access would be 'private. If TYPE is inherited by a member of SCOPE,
459 "Calculate the access class for TYPE as defined by the current SCOPE."
463 )
465 ;; Investigate the parent, and see how it relates to type.
466 ;; If these tags are basically the same, then we have full access.
470 )
471 ;; Look to see if type is in our list of inherited parents.
473 ;; pi is a cons cell ( PARENT . protection)
478 ;; protection via inheritance means to pull out different
479 ;; bits based on protection labels in an opposite way.
484 )))
485 )
486 ;; Not in our parentage. Is type a FRIEND?
492 )))
493 ;; Found nothing, return public
495 ))
499 "Return a list of slots that are valid completions from the list of SLOTS.
500 If a tag in SLOTS has a named parent, then that implies that the
501 tag is not something you can complete from within TYPE."
504 )
509 )
513 "Return all parts of TYPE, a tag representing a TYPE declaration.
514 SCOPE is the scope object.
515 NOINHERIT turns off searching of inherited tags.
516 PROTECTION specifies the type of access requested, such as 'public or 'private."
518 nil
520 ;; SLOTS are the slots directly a part of TYPE.
523 access
524 type allslots))
526 ;; EXTMETH are externally defined methods that are still
527 ;; a part of this class.
529 ;; @TODO - is this line needed?? Try w/out for a while
530 ;; @note - I think C++ says no. elisp might, but methods
531 ;; look like defuns, so it makes no difference.
534 ;; INHERITED are tags found in classes that our TYPE tag
535 ;; inherits from. Do not do this if it was not requested.
538 access)))
539 )
543 ;;(semantic--tag-put-property TAG :filename fname)
545 ;; If it has a filename, just go with it...
547 ;; Otherwise, copy the tag w/ the guessed filename.
549 copyslots)))
550 )
552 ))
553 ;; Flatten the database output.
555 )))
558 "Return all tags that TYPE inherits from.
559 Argument SCOPE specify additional tags that are in scope
560 whose tags can be searched when needed, OR it may be a scope object.
561 ACCESS is the level of access we filter on child supplied tags.
562 For languages with protection on specific methods or slots,
563 it should strip out those not accessible by methods of TYPE.
564 An ACCESS of 'public means not in a method of a subclass of type.
565 A value of 'private means we can access private parts of the originating
566 type."
572 type pname))
573 )
575 nil ;; Don't do it.
577 ;; We can get some parts of this type.
579 ;; Do not pull in inherited parts here. Those
580 ;; will come via the inherited-tag-map fcn
582 p scope t protection))
583 ))))
584 scope)
585 ret))
588 "Map all parents of TYPE to FCN. Return tags of all the types.
589 Argument SCOPE specify additional tags that are in scope
590 whose tags can be searched when needed, OR it may be a scope object."
593 ;; interfaces. Inheriting from an interfaces implies
594 ;; you have a copy of all methods locally. I think.
596 ps pt
598 )
601 ;; Create a SCOPE just for looking up the parent based on where
602 ;; the parent came from.
603 ;;
604 ;; @TODO - Should we cache these mini-scopes around in Emacs
605 ;; for recycling later? Should this become a helpful
606 ;; extra routine?
609 ;; If TYPE has a position, go there and get the scope.
612 ;; We need to make a mini scope, and only include the misc bits
613 ;; that will help in finding the parent. We don't really need
614 ;; to do any of the stuff related to variables and what-not.
619 ;;(parentinherited (semantic-analyze-scope-lineage-tags parents scopetypes))
621 )
624 ;;(oset tmpscope parentinheritance parentinherited)
630 )))
631 ;; END creating tmpscope
633 ;; Look up each parent one at a time.
639 p))
642 ;; A backup hack.
648 ;; Note that we pass the original SCOPE in while recursing.
649 ;; so that the correct inheritance model is passed along.
651 )))
652 nil))
654 ;;; ANALYZER
655 ;;
656 ;; Create the scope structure for use in the Analyzer.
657 ;;
658 ;;;###autoload
660 "Calculate the scope at POINT.
661 If POINT is not provided, then use the current location of point.
662 The class returned from the scope calculation is variable
663 `semantic-scope-cache'."
666 nil ;; Don't do anything...
677 semantic-scope-cache))
678 )
682 ;; Even though we can recycle most of the scope, we
683 ;; need to redo the local variables since those change
684 ;; as you move about the tag.
693 parents scopetypes))
694 )
703 )
704 ;; Step 3:
709 )
711 ;; Try looking for parents again.
717 ;; Try calculating the scope again with the new inherited parent list.
720 )))
722 ;; Fill out the scope.
727 )))
728 ;; Make sure we become dependant on the typecache.
730 ;; Handy debug output.
734 ;; Return ourselves
735 scopecache))))
738 "Find the tag with NAME, and optional CLASS in the current SCOPE-IN.
739 Searches various elements of the scope for NAME. Return ALL the
740 hits in order, with the first tag being in the closest scope."
743 ;; Is the passed in scope really a scope? if so, look through
744 ;; the options in that scope.
747 ;; This should be first, but bugs in the
748 ;; C parser will turn function calls into
749 ;; assumed int return function prototypes. Yuck!
757 )
760 ;; Scan out things not of the right class.
763 )
768 ;; It may be we need to hack our way through type typescope.
772 typescoperaw)
774 fullscoperaw)
775 ))
783 ;; Once done, store the current typecache lookup
786 )))
787 ;; Return it.
788 ans)
789 ;; Not a real scope. Our scope calculation analyze parts of
790 ;; what it finds, and needs to pass lists through to do it's work.
791 ;; Tread that list as a singly entry.
794 scope)
795 )))
797 ;;; DUMP
798 ;;
800 "Insert CONTEXT into the current buffer in a nice way."
805 ;;(semantic-analyze-princ-sequence (oref context fullscope) "Fullscope: " )
808 )
812 ;; Local variables:
813 ;; generated-autoload-file: "loaddefs.el"
814 ;; generated-autoload-load-name: "semantic/scope"
815 ;; End:
817 ;;; semantic/scope.el ends here